private void handleEnd() {
        Handler<Void> endHandler;
        lock.lock();
        try {
            dataHandler = null;
            endHandler = this.endHandler;
        } finally {
            lock.unlock();
        }
        if (endHandler != null) {
            checkContext();
            endHandler.handle(null);
        }
    }

    public GenericFileProcessStrategy<FTPFile> createGenericFileProcessStrategy(
            CamelContext context, Map<String, Object> params) {

         
         
        Expression moveExpression = (Expression) params.get("move");
        Expression moveFailedExpression = (Expression) params.get("moveFailed");
        Expression preMoveExpression = (Expression) params.get("preMove");
        boolean isNoop = params.get("noop") != null;
        boolean isDelete = params.get("delete") != null;
        boolean isMove = moveExpression != null || preMoveExpression != null || moveFailedExpression != null;

        if (isDelete) {
            GenericFileDeleteProcessStrategy<FTPFile> strategy = new GenericFileDeleteProcessStrategy<>();
            strategy.setExclusiveReadLockStrategy(getExclusiveReadLockStrategy(params));
            if (preMoveExpression != null) {
                GenericFileExpressionRenamer<FTPFile> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(preMoveExpression);
                strategy.setBeginRenamer(renamer);
            }
            if (moveFailedExpression != null) {
                GenericFileExpressionRenamer<FTPFile> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(moveFailedExpression);
                strategy.setFailureRenamer(renamer);
            }
            return strategy;
        } else if (isMove || isNoop) {
            GenericFileRenameProcessStrategy<FTPFile> strategy = new GenericFileRenameProcessStrategy<>();
            strategy.setExclusiveReadLockStrategy(getExclusiveReadLockStrategy(params));
            if (!isNoop && moveExpression != null) {
                 
                GenericFileExpressionRenamer<FTPFile> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(moveExpression);
                strategy.setCommitRenamer(renamer);
            }
             
            if (moveFailedExpression != null) {
                GenericFileExpressionRenamer<FTPFile> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(moveFailedExpression);
                strategy.setFailureRenamer(renamer);
            }
             
            if (preMoveExpression != null) {
                GenericFileExpressionRenamer<FTPFile> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(preMoveExpression);
                strategy.setBeginRenamer(renamer);
            }
            return strategy;
        } else {
             
            GenericFileNoOpProcessStrategy<FTPFile> strategy = new GenericFileNoOpProcessStrategy<>();
            strategy.setExclusiveReadLockStrategy(getExclusiveReadLockStrategy(params));
            return strategy;
        }
    }

    public Exchange add(CamelContext camelContext, String key, Exchange exchange) {
        if (optimistic) {
            throw new UnsupportedOperationException();
        }
        LOG.trace("Adding an Exchange with ID {} for key {} in a thread-safe manner.", exchange.getExchangeId(), key);
        Lock l = hazelcastInstance.getCPSubsystem().getLock(mapName);
        try {
            l.lock();
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(exchange, true, allowSerializedHeaders);
            DefaultExchangeHolder oldHolder = cache.put(key, newHolder);
            return unmarshallExchange(camelContext, oldHolder);
        } finally {
            LOG.trace("Added an Exchange with ID {} for key {} in a thread-safe manner.", exchange.getExchangeId(), key);
            l.unlock();
        }
    }

    public void execute(Exchange exchange) throws SmppException {
        CancelSm cancelSm = createCancelSm(exchange);

        if (log.isDebugEnabled()) {
            log.debug("Canceling a short message for exchange id '{}' and message id '{}'",
                    exchange.getExchangeId(), cancelSm.getMessageId());
        }

        try {
            session.cancelShortMessage(
                    cancelSm.getServiceType(),
                    cancelSm.getMessageId(),
                    TypeOfNumber.valueOf(cancelSm.getSourceAddrTon()),
                    NumberingPlanIndicator.valueOf(cancelSm.getSourceAddrNpi()),
                    cancelSm.getSourceAddr(),
                    TypeOfNumber.valueOf(cancelSm.getDestAddrTon()),
                    NumberingPlanIndicator.valueOf(cancelSm.getDestAddrNpi()),
                    cancelSm.getDestinationAddress());
        } catch (Exception e) {
            throw new SmppException(e);
        }

        if (log.isDebugEnabled()) {
            log.debug("Cancel a short message for exchange id '{}' and message id '{}'",
                    exchange.getExchangeId(), cancelSm.getMessageId());
        }

        Message message = ExchangeHelper.getResultMessage(exchange);
        message.setHeader(SmppConstants.ID, cancelSm.getMessageId());
    }

    private void tryFlush() {
        lock.lock();
        try {
            flush();
        } catch (IOException e) {
            LOG.error("Unable to save record: {}", e.getMessage(), e);
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }
    }

    protected void initialize() {
         
         
        getOutFilter().add(JmsConstants.JMS_HEADER_XUSER_ID);
        getOutFilter().add("JMSXAppID");
        getOutFilter().add("JMSXDeliveryCount");
        getOutFilter().add("JMSXProducerTXID");
        getOutFilter().add("JMSXConsumerTXID");
        getOutFilter().add("JMSXRcvTimestamp");
        getOutFilter().add("JMSXRecvTimestamp");
        getOutFilter().add("JMSXState");
    }

    void processCompositeResponse(
            final Exchange exchange, final Optional<SObjectCompositeResponse> responseBody, final Map<String, String> headers,
            final SalesforceException exception, final AsyncCallback callback) {
        try {
            if (!responseBody.isPresent()) {
                exchange.setException(exception);
            } else {
                final Message in = exchange.getIn();
                final Message out = exchange.getOut();

                final SObjectCompositeResponse response = responseBody.get();

                out.copyFromWithNewBody(in, response);
                out.getHeaders().putAll(headers);
            }
        } finally {
             
            callback.done(false);
        }
    }

    public static void closeAllAsyncMdnServerConnections() {
        for (Map.Entry<Integer, AS2AsyncMDNServerConnection> entry : asyncMdnServerConnections.entrySet()) {
            try {
                int port = entry.getKey();
                LOG.debug("Stopping and closing AsyncMdnServerConnection on port: {}", port);
                entry.getValue().close();
            } catch (Exception e) {
                LOG.debug("Error stopping and closing AsyncMdnServerConnection due to {}. This exception is ignored",
                        e.getMessage(), e);
            }
        }
        asyncMdnServerConnections.clear();
    }

    protected void setRegisterDeliveryReceiptFlag(SubmitMulti[] submitMulties, Message message) {
        byte specifiedDeliveryFlag = getRegisterDeliveryFlag(message);
        byte flag;
        if (getRequestsSingleDLR(message)) {
             
            flag = SMSCDeliveryReceipt.DEFAULT.value();
        } else {
            flag = specifiedDeliveryFlag;
        }

        for (int i = 0; i < submitMulties.length - 1; i++) {
            submitMulties[i].setRegisteredDelivery(flag);
        }
        submitMulties[submitMulties.length - 1].setRegisteredDelivery(specifiedDeliveryFlag);
    }

    protected void doPull(Exchange exchange, String operation) throws GitAPIException {
        PullResult result = null;
        try {
            if (ObjectHelper.isEmpty(endpoint.getRemoteName())) {
                throw new IllegalArgumentException("Remote name must be specified to execute " + operation);
            }
            if (ObjectHelper.isNotEmpty(endpoint.getBranchName())) {
                git.checkout().setCreateBranch(false).setName(endpoint.getBranchName()).call();
            }
            if (ObjectHelper.isNotEmpty(endpoint.getUsername()) && ObjectHelper.isNotEmpty(endpoint.getPassword())) {
                UsernamePasswordCredentialsProvider credentials
                        = new UsernamePasswordCredentialsProvider(endpoint.getUsername(), endpoint.getPassword());
                result = git.pull().setCredentialsProvider(credentials).setRemote(endpoint.getRemoteName()).call();
            } else {
                result = git.pull().setRemote(endpoint.getRemoteName()).call();
            }
        } catch (GitAPIException e) {
            LOG.error("There was an error in Git {} operation", operation);
            throw e;
        }
        updateExchange(exchange, result);
    }

    private DaprOperationResponse waitForInstanceCompletion(Exchange exchange, DaprWorkflowClient client) {
        String instanceId = configurationOptionsProxy.getWorkflowInstanceId(exchange);
        Duration timeout = configurationOptionsProxy.getTimeout(exchange);
        boolean getWorkflowIO = configurationOptionsProxy.getWorkflowIO(exchange);

        try {
            WorkflowInstanceStatus response = client.waitForInstanceCompletion(instanceId, timeout, getWorkflowIO);
            return DaprOperationResponse.createFromWorkflowStatus(response);
        } catch (TimeoutException exception) {
            throw new RuntimeCamelException(
                    "Workflow instance " + instanceId + " could not be completed in " + timeout, exception);
        }
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.io.InputStream.class, org.apache.camel.component.file.GenericFile.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.file.GenericFileConverter.genericFileToInputStream((org.apache.camel.component.file.GenericFile) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.io.Reader.class, org.apache.camel.component.file.GenericFile.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.file.GenericFileConverter.genericFileToReader((org.apache.camel.component.file.GenericFile) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.io.Serializable.class, org.apache.camel.component.file.GenericFile.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.file.GenericFileConverter.genericFileToSerializable((org.apache.camel.component.file.GenericFile) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.lang.String.class, org.apache.camel.component.file.GenericFile.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.file.GenericFileConverter.genericFileToString((org.apache.camel.component.file.GenericFile) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    public static Method findMethod(Class<?> clazz, String name, Class<?>... paramTypes) {
        ObjectHelper.notNull(clazz, "Class must not be null");
        ObjectHelper.notNull(name, "Method name must not be null");
        Class<?> searchType = clazz;
        while (searchType != null) {
            Method[] methods = searchType.isInterface() ? searchType.getMethods() : searchType.getDeclaredMethods();
            for (Method method : methods) {
                if (name.equals(method.getName())
                        && (paramTypes == null || Arrays.equals(paramTypes, method.getParameterTypes()))) {
                    return method;
                }
            }
            searchType = searchType.getSuperclass();
        }
        return null;
    }

    private void reconnect() throws InterruptedException, IOException, SmackException, XMPPException {
        lock.lock();
        try {
            if (!connection.isConnected()) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("Reconnecting to: {}", XmppEndpoint.getConnectionMessage(connection));
                }
                connection.connect();
            }
        } finally {
            lock.unlock();
        }
    }

        protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
            doBeforeParse(element);
            super.doParse(element, parserContext, builder);

             
            Binder<Node> binder;
            try {
                binder = getJaxbContext().createBinder();
            } catch (JAXBException e) {
                throw new BeanDefinitionStoreException("Failed to create the JAXB binder", e);
            }
            Object value = parseUsingJaxb(element, parserContext, binder);

            if (value instanceof CamelEndpointFactoryBean) {
                CamelEndpointFactoryBean factoryBean = (CamelEndpointFactoryBean) value;
                builder.addPropertyValue("properties", factoryBean.getProperties());
            }
        }

    private static void parseApplicationPkcs7MimeEnvelopedEntity(
            HttpMessage message, InputStream is, AS2SessionInputBuffer inBuffer, ContentType contentType,
            String contentTransferEncoding)
            throws HttpException {
        ApplicationPkcs7MimeEnvelopedDataEntity applicationPkcs7MimeEnvelopedDataEntity = null;

        ObjectHelper.notNull(message, "message");
        ObjectHelper.notNull(inBuffer, "inBuffer");

        HttpEntity entity = ObjectHelper.notNull(EntityUtils.getMessageEntity(message), "message entity");

        if (entity instanceof ApplicationPkcs7MimeCompressedDataEntity) {
             
            return;
        }

        Args.check(entity.isStreaming(), "Message entity can not be parsed: entity is not streaming");

        try {

            applicationPkcs7MimeEnvelopedDataEntity
                    = parseApplicationPkcs7MimeEnvelopedDataEntityBody(inBuffer, is, null, contentType,
                            contentTransferEncoding);
            applicationPkcs7MimeEnvelopedDataEntity.setMainBody(true);

            EntityUtils.setMessageEntity(message, applicationPkcs7MimeEnvelopedDataEntity);

        } catch (Exception e) {
            throw new HttpException("Failed to parse entity content", e);
        }
    }

    private ScrollResponse<TDocument> scrollSearch() {
        ScrollResponse<TDocument> scrollResponse;
        try {
            ScrollRequest searchScrollRequest = new ScrollRequest.Builder()
                    .scroll(Time.of(b -> b.time(String.format("%sms", scrollKeepAliveMs))))
                    .scrollId(scrollId)
                    .build();

            scrollResponse = esClient.scroll(searchScrollRequest, documentClass);
            requestCount++;
        } catch (IOException e) {
            throw new IllegalStateException(e);
        }
        return scrollResponse;
    }

    public SmppMessage createSmppMessage(CamelContext camelContext, DataSm dataSm, String smppMessageId) {
        SmppMessage smppMessage = new SmppMessage(camelContext, dataSm, configuration);

        smppMessage.setHeader(SmppConstants.MESSAGE_TYPE, SmppMessageType.DataSm.toString());
        smppMessage.setHeader(SmppConstants.ID, smppMessageId);
        smppMessage.setHeader(SmppConstants.SEQUENCE_NUMBER, dataSm.getSequenceNumber());
        smppMessage.setHeader(SmppConstants.COMMAND_ID, dataSm.getCommandId());
        smppMessage.setHeader(SmppConstants.COMMAND_STATUS, dataSm.getCommandStatus());
        smppMessage.setHeader(SmppConstants.SOURCE_ADDR, dataSm.getSourceAddr());
        smppMessage.setHeader(SmppConstants.SOURCE_ADDR_NPI, dataSm.getSourceAddrNpi());
        smppMessage.setHeader(SmppConstants.SOURCE_ADDR_TON, dataSm.getSourceAddrTon());
        smppMessage.setHeader(SmppConstants.DEST_ADDR, dataSm.getDestAddress());
        smppMessage.setHeader(SmppConstants.DEST_ADDR_NPI, dataSm.getDestAddrNpi());
        smppMessage.setHeader(SmppConstants.DEST_ADDR_TON, dataSm.getDestAddrTon());
        smppMessage.setHeader(SmppConstants.SERVICE_TYPE, dataSm.getServiceType());
        smppMessage.setHeader(SmppConstants.REGISTERED_DELIVERY, dataSm.getRegisteredDelivery());
        smppMessage.setHeader(SmppConstants.DATA_CODING, dataSm.getDataCoding());

        return smppMessage;
    }

    protected void doListBuildConfigsByLabels(Exchange exchange) {
        Map<String, String> labels = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_BUILD_CONFIGS_LABELS, Map.class);
        String namespaceName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        BuildConfigList buildConfigsList;
        if (!ObjectHelper.isEmpty(namespaceName)) {
            buildConfigsList = getEndpoint().getKubernetesClient().adapt(OpenShiftClient.class).buildConfigs()
                    .inNamespace(namespaceName).withLabels(labels).list();
        } else {
            buildConfigsList = getEndpoint().getKubernetesClient().adapt(OpenShiftClient.class).buildConfigs()
                    .inAnyNamespace().withLabels(labels).list();
        }
        prepareOutboundMessage(exchange, buildConfigsList.getItems());
    }

    private AttachContainerCmd executeAttachContainerRequest(DockerClient client, Message message) {

        LOG.debug("Executing Docker Attach Container Request");

        String containerId
                = DockerHelper.getProperty(DockerConstants.DOCKER_CONTAINER_ID, configuration, message, String.class);

        ObjectHelper.notNull(containerId, MISSING_CONTAINER_ID);

        AttachContainerCmd attachContainerCmd = client.attachContainerCmd(containerId);

        Boolean followStream
                = DockerHelper.getProperty(DockerConstants.DOCKER_FOLLOW_STREAM, configuration, message, Boolean.class);

        if (followStream != null) {
            attachContainerCmd.withFollowStream(followStream);
        }

        Boolean logs = DockerHelper.getProperty(DockerConstants.DOCKER_LOGS, configuration, message, Boolean.class);

        if (logs != null) {
            attachContainerCmd.withLogs(logs);
        }

        Boolean stdErr = DockerHelper.getProperty(DockerConstants.DOCKER_STD_ERR, configuration, message, Boolean.class);

        if (stdErr != null) {
            attachContainerCmd.withStdErr(stdErr);
        }

        Boolean stdOut = DockerHelper.getProperty(DockerConstants.DOCKER_STD_OUT, configuration, message, Boolean.class);

        if (stdOut != null) {
            attachContainerCmd.withStdOut(stdOut);
        }

        Boolean timestamps = DockerHelper.getProperty(DockerConstants.DOCKER_TIMESTAMPS, configuration, message, Boolean.class);

        if (timestamps != null) {
            attachContainerCmd.withTimestamps(timestamps);
        }

        return attachContainerCmd;

    }

    private void setAdditionalConfiguration(RestConfiguration config, String prefix, PropertyBindingSupport.Builder builder) {
        if (config.getDataFormatProperties() != null && !config.getDataFormatProperties().isEmpty()) {
             
             
            Map<String, Object> copy = new HashMap<>();

             
             
             
            for (Map.Entry<String, Object> entry : config.getDataFormatProperties().entrySet()) {
                String key = entry.getKey();
                String copyKey;
                boolean known = isKeyKnownPrefix(key);
                if (known) {
                     
                    copyKey = key.substring(prefix.length());
                } else {
                     
                    copyKey = key;
                }
                if (!known || key.startsWith(prefix)) {
                    copy.put(copyKey, entry.getValue());
                }
            }

            builder.withProperties(copy);
        }
    }

    private void generateUploadUrl(CloudFunctionsServiceClient client, Exchange exchange)
            throws InvalidPayloadException {
        GenerateUploadUrlResponse response = null;
        if (getConfiguration().isPojoRequest()) {
            GenerateUploadUrlRequest request = exchange.getIn().getMandatoryBody(GenerateUploadUrlRequest.class);
            response = client.generateUploadUrl(request);
        } else {
            LocationName locationName = LocationName.of(getConfiguration().getProject(),
                    getConfiguration().getLocation());
            GenerateUploadUrlRequest request = GenerateUploadUrlRequest.newBuilder().setParent(locationName.toString())
                    .build();
            response = client.generateUploadUrl(request);
        }
        Message message = getMessageForResponse(exchange);
        message.setHeader(GoogleCloudFunctionsConstants.RESPONSE_OBJECT, response);
        message.setBody(response.getUploadUrl());
    }

    protected ScheduledExecutorService getExecutorService(
            ScheduledExecutorService executorService, String executorServiceRef) {
        lock.lock();
        try {
            if (executorService == null || executorService.isShutdown()) {
                 
                 
                if (executorServiceRef != null) {
                    executorService = lookupByNameAndType(executorServiceRef, ScheduledExecutorService.class);
                    if (executorService == null) {
                        ExecutorServiceManager manager = camelContext.getExecutorServiceManager();
                        ThreadPoolProfile profile = manager.getThreadPoolProfile(executorServiceRef);
                        executorService = manager.newScheduledThreadPool(this, executorServiceRef, profile);
                    }
                    if (executorService == null) {
                        throw new IllegalArgumentException("ExecutorService " + executorServiceRef + " not found in registry.");
                    }
                } else {
                     
                     
                     
                    executorService = null;
                }
            }
            return executorService;
        } finally {
            lock.unlock();
        }
    }

    <T> Optional<T> tryToReadResponse(final Class<T> expectedType, final InputStream responseStream) {
        if (responseStream == null) {
            return Optional.empty();
        }
        try {
            return Optional.of(fromJson(expectedType, responseStream));
        } catch (IOException e) {
            log.warn("Unable to read response from the Composite API", e);
            return Optional.empty();
        } finally {
            IOHelper.close(responseStream);
        }
    }

    public Set<Class<?>> findAnnotated(Class<? extends Annotation> annotation, String... packageNames) {
        if (packageNames == null) {
            return Collections.emptySet();
        }

        if (LOG.isDebugEnabled()) {
            LOG.debug("Searching for annotations of {} in packages: {}", annotation.getName(), Arrays.asList(packageNames));
        }

        PackageScanFilter test = getCompositeFilter(new AnnotatedWithPackageScanFilter(annotation, true));
        Set<Class<?>> classes = new LinkedHashSet<>();
        for (String pkg : packageNames) {
            find(test, pkg, classes);
        }

        LOG.debug("Found: {}", classes);

        return classes;
    }

    public Olingo4AppWrapper createApiProxy(Olingo4Configuration endpointConfiguration) {
        final Olingo4AppWrapper result;
        if (endpointConfiguration.equals(getConfiguration())) {
            lock.lock();
            try {
                if (apiProxy == null) {
                    apiProxy = createOlingo4App(getConfiguration());
                }
            } finally {
                lock.unlock();
            }
            result = apiProxy;
        } else {
            result = createOlingo4App(endpointConfiguration);
        }
        return result;
    }

    public static AS2MessageDispositionNotificationEntity parseMessageDispositionNotificationEntityBody(
            AS2SessionInputBuffer inbuffer,
            InputStream is,
            String boundary,
            String charsetName)
            throws ParseException {
        CharsetDecoder previousDecoder = inbuffer.getCharsetDecoder();

        try {

            if (charsetName == null) {
                charsetName = StandardCharsets.US_ASCII.name();
            }
            Charset charset = Charset.forName(charsetName);
            CharsetDecoder charsetDecoder = charset.newDecoder();

            inbuffer.setCharsetDecoder(charsetDecoder);

            List<CharArrayBuffer> dispositionNotificationFields = parseBodyPartFields(inbuffer, is, boundary,
                    BasicLineParser.INSTANCE, new ArrayList<>());

            AS2MessageDispositionNotificationEntity as2MessageDispositionNotificationEntity
                    = DispositionNotificationContentUtils.parseDispositionNotification(dispositionNotificationFields);
            return as2MessageDispositionNotificationEntity;
        } catch (Exception e) {
            ParseException parseException = new ParseException("failed to parse MDN entity");
            parseException.initCause(e);
            throw parseException;
        } finally {
            inbuffer.setCharsetDecoder(previousDecoder);
        }
    }

    public void transform(Message message, DataType fromType, DataType toType) {
        final Map<String, Object> headers = message.getHeaders();

        CloudEvent cloudEvent = CloudEvents.v1_0;
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_ID, message.getExchange().getExchangeId());
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_VERSION, cloudEvent.version());
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TYPE, "org.apache.camel.event.azure.eventhubs.consume");

        if (message.getHeaders().containsKey(EventHubsConstants.PARTITION_ID)) {
            headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SOURCE,
                    "azure.eventhubs." + message.getHeader(EventHubsConstants.PARTITION_ID, String.class));
        }

        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SUBJECT, message.getHeader(EventHubsConstants.SEQUENCE_NUMBER, Long.class));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TIME, cloudEvent.getEventTime(message.getExchange()));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_CONTENT_TYPE, CloudEvent.APPLICATION_OCTET_STREAM_MIME_TYPE);
    }

    protected Publisher<Exchange> doRequest(String name, Exchange data) {
        ReactiveStreamsConsumer consumer = streamSubscriber(name).getConsumer();
        if (consumer == null) {
            throw new IllegalStateException("No consumers attached to the stream " + name);
        }

        return Mono.<Exchange> create(
                sink -> data.getExchangeExtension().addOnCompletion(new Synchronization() {
                    @Override
                    public void onComplete(Exchange exchange) {
                        sink.success(exchange);
                    }

                    @Override
                    public void onFailure(Exchange exchange) {
                        Throwable throwable = exchange.getException();
                        if (throwable == null) {
                            throwable = new IllegalStateException("Unknown Exception");
                        }

                        sink.error(throwable);
                    }
                })).doOnSubscribe(
                        subs -> consumer.process(data, ReactorStreamsConstants.EMPTY_ASYNC_CALLBACK));
    }

    public void process(Exchange exchange, String message) {
        if (logger.shouldLog()) {
            String output = formatter.format(exchange) + message;
            if (maskingFormatter != null) {
                output = maskingFormatter.format(output);
            }
            output = fireListeners(exchange, output);
            logger.log(output);
            closeListeners(exchange, output);
        }
    }

    private void startIngestionJob(BedrockAgentClient bedrockAgentClient, Exchange exchange)
            throws InvalidPayloadException {
        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getMessage().getMandatoryBody();
            if (payload instanceof StartIngestionJobRequest) {
                StartIngestionJobResponse result;
                try {
                    result = bedrockAgentClient.startIngestionJob((StartIngestionJobRequest) payload);
                } catch (AwsServiceException ase) {
                    LOG.trace("Start Ingestion Job command returned the error code {}", ase.awsErrorDetails().errorCode());
                    throw ase;
                }
                Message message = getMessageForResponse(exchange);
                prepareIngestionJobResponse(result, message);
            }
        } else {
            String knowledgeBaseId;
            String dataSourceId;
            StartIngestionJobRequest.Builder builder = StartIngestionJobRequest.builder();
            if (ObjectHelper.isEmpty(getConfiguration().getKnowledgeBaseId())) {
                if (ObjectHelper.isNotEmpty(exchange.getMessage().getHeader(BedrockAgentConstants.KNOWLEDGE_BASE_ID))) {
                    knowledgeBaseId = exchange.getIn().getHeader(BedrockAgentConstants.KNOWLEDGE_BASE_ID, String.class);
                } else {
                    throw new IllegalArgumentException("KnowledgeBaseId must be specified");
                }
            } else {
                knowledgeBaseId = getConfiguration().getKnowledgeBaseId();
            }
            if (ObjectHelper.isEmpty(getConfiguration().getDataSourceId())) {
                if (ObjectHelper.isNotEmpty(exchange.getMessage().getHeader(BedrockAgentConstants.DATASOURCE_ID))) {
                    dataSourceId = exchange.getIn().getHeader(BedrockAgentConstants.DATASOURCE_ID, String.class);
                } else {
                    throw new IllegalArgumentException("DataSourceId must be specified");
                }
            } else {
                dataSourceId = getConfiguration().getDataSourceId();
            }
            builder.knowledgeBaseId(knowledgeBaseId);
            builder.dataSourceId(dataSourceId);
            StartIngestionJobResponse output = bedrockAgentClient.startIngestionJob(builder.build());
            Message message = getMessageForResponse(exchange);
            prepareIngestionJobResponse(output, message);
        }
    }

    public String getLastChosenProcessorId() {
        int idx = getProcessor().getLastChosenProcessorIndex();
        if (idx != -1) {
            LoadBalanceDefinition def = getDefinition();
            ProcessorDefinition<?> output = def.getOutputs().get(idx);
            if (output != null) {
                return output.getId();
            }
        }
        return null;
    }

    protected void doStart() throws Exception {
        super.doStart();
        cache = CamelContextHelper.lookup(getCamelContext(), cacheName, LoadingCache.class);
        if (cache == null) {
            if (configuration.isCreateCacheIfNotExist()) {
                cache = getComponent().getOrCreateCache(cacheName, configuration);
            } else {
                throw new IllegalArgumentException(
                        "LoadingCache instance '" + cacheName + "' not found and createCacheIfNotExist is set to false");
            }
        }
    }

    public static void configureConnects(Traits traitsSpec, String[] connects) {
        if (connects == null || connects.length == 0) {
            return;
        }
        ServiceBinding serviceBindingTrait = Optional.ofNullable(traitsSpec.getServiceBinding()).orElseGet(ServiceBinding::new);
        if (serviceBindingTrait.getServices() == null) {
            serviceBindingTrait.setServices(new ArrayList<>());
        }
        serviceBindingTrait.getServices().addAll(List.of(connects));
        traitsSpec.setServiceBinding(serviceBindingTrait);
    }

        public void parse(String systemId) throws IOException, SAXException {
            lock.lock();
            try {
                checkValid();
                try {
                    xmlReader.parse(systemId);
                } finally {
                    release();
                }
            } finally {
                lock.unlock();
            }
        }

    public MessageHistory newMessageHistory(String routeId, NamedNode node, Exchange exchange) {
        if (nodePatternParts != null) {
            String name = node.getShortName();
            for (String part : nodePatternParts) {
                boolean match = PatternHelper.matchPattern(name, part);
                if (!match) {
                    return null;
                }
            }
        }

        Message msg = null;
        if (copyMessage) {
            msg = exchange.getMessage().copy();
        }

        DefaultMessageHistory answer = new DefaultMessageHistory(routeId, node, msg);
        answer.setAcceptDebugger(node.acceptDebugger(exchange));
        return answer;
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        String[] parts = remaining.split(":");

        if (parts.length < 2) {
            throw new IllegalArgumentException("Google BigQuery Endpoint format \"projectId:datasetId:tableName\"");
        }

        GoogleBigQueryConfiguration conf = configuration != null ? configuration.copy() : new GoogleBigQueryConfiguration();
        conf.parseRemaining(remaining);

        GoogleBigQueryEndpoint endpoint = new GoogleBigQueryEndpoint(uri, this, conf);
        setProperties(endpoint, parameters);
        return endpoint;
    }

    protected void doStop() throws Exception {
        super.doStop();

        if (stopClient && client != null && client.isConnected()) {
            String topic = getEndpoint().getTopic();
             
            if (getEndpoint().getConfiguration().isCleanStart()) {
                LOG.debug("Unsubscribing client: {} from topic: {}", clientId, topic);
                client.unsubscribe(topic);
            } else {
                LOG.debug("Client: {} is durable so will not unsubscribe from topic: {}", clientId, topic);
            }
            LOG.debug("Disconnecting client: {} from broker: {}", clientId, getEndpoint().getConfiguration().getBrokerUrl());
            client.disconnect();
        }
        client = null;
    }

            public void onResponse(InputStream response, Map<String, String> responseHeaders, SalesforceException ex) {
                if (ex != null) {
                    callback.onResponse(null, responseHeaders, ex);
                    return;
                }
                QueryJob queryJob = null;
                try {
                    queryJob = DefaultBulkApiV2Client.this.unmarshalResponse(response, request,
                            QueryJob.class);
                } catch (SalesforceException e) {
                    ex = e;
                }
                callback.onResponse(queryJob, responseHeaders, ex);
            }

    private long determineDelay(final Exchange exchange, Athena2Configuration configuration) {
        Long delay = exchange.getIn().getHeader(Athena2Constants.DELAY, Long.class);

        if (ObjectHelper.isEmpty(delay)) {
            delay = configuration.getDelay();
            LOG.trace("AWS Athena delay is missing, using default one [{}]", delay);
        }

        if (ObjectHelper.isEmpty(delay)) {
            throw new IllegalArgumentException("AWS Athena delay is required.");
        }

        if (delay < 0) {
            throw new IllegalArgumentException("AWS Athena delay must be >= 0");
        }

        return delay;
    }

    public void transform(Message message, DataType fromType, DataType toType) {
        final Map<String, Object> headers = message.getHeaders();

        CloudEvent cloudEvent = CloudEvents.v1_0;
        headers.putIfAbsent(CloudEvents.CAMEL_CLOUD_EVENT_ID, message.getExchange().getExchangeId());
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_VERSION, cloudEvent.version());
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_TYPE, "org.apache.camel.event.google.pubsub.pull");

        if (message.getHeaders().containsKey(GooglePubsubConstants.ACK_ID)) {
            headers.put(CloudEvents.CAMEL_CLOUD_EVENT_SOURCE,
                    "google.pubsub." + message.getHeader(GooglePubsubConstants.ACK_ID, String.class));
        }

        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_SUBJECT, message.getHeader(GooglePubsubConstants.MESSAGE_ID, String.class));
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_TIME, cloudEvent.getEventTime(message.getExchange()));
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_CONTENT_TYPE, CloudEvents.APPLICATION_OCTET_STREAM_MIME_TYPE);
    }

    protected void doStart() throws Exception {
        super.doStart();

        if (useJmx) {
            ManagementAgent agent = getCamelContext().getManagementStrategy().getManagementAgent();
            if (agent != null) {
                MBeanServer server = agent.getMBeanServer();
                if (server != null) {
                    reporter = JmxReporter.forRegistry(metricsRegistry).registerWith(server).inDomain(jmxDomain).build();
                    reporter.start();
                }
            } else {
                throw new IllegalStateException("CamelContext has not enabled JMX");
            }
        }
    }

    protected void doDeleteNode(Exchange exchange) {
        String nodeName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NODE_NAME, String.class);
        if (ObjectHelper.isEmpty(nodeName)) {
            LOG.error("Deleting a specific Node require specify a Node name");
            throw new IllegalArgumentException("Deleting a specific Node require specify a Node name");
        }

        List<StatusDetails> statusDetails = getEndpoint().getKubernetesClient().nodes().withName(nodeName).delete();
        boolean nodeDeleted = ObjectHelper.isNotEmpty(statusDetails);

        prepareOutboundMessage(exchange, nodeDeleted);
    }

    public void close() {
        if (!closed) {
            try {
                ClearScrollRequest clearScrollRequest = new ClearScrollRequest.Builder()
                        .scrollId(List.of(scrollId))
                        .build();

                esClient.clearScroll(clearScrollRequest);
                closed = true;
                exchange.setProperty(OpensearchConstants.PROPERTY_SCROLL_OPENSEARCH_QUERY_COUNT, requestCount);
            } catch (IOException e) {
                throw new IllegalStateException(e);
            }
        }
    }

    public void execute() throws MojoExecutionException, MojoFailureException {
        if (!mainJsonFile.exists()) {
             
            return;
        }

        File file = new File(docDocDir, "main.adoc");
        boolean exists = file.exists();
        boolean updated;
        try {
            String json = PackageHelper.loadText(mainJsonFile);
            MainModel model = JsonMapper.generateMainModel(json);
            String options = evaluateTemplate("main-options.mvel", model);
            updated = updateOptionsIn(file, "main", options);
        } catch (IOException e) {
            throw new MojoExecutionException("Error preparing main docs", e);
        }

        if (updated) {
            getLog().info("Updated doc file: " + file);
        } else if (exists) {
            if (getLog().isDebugEnabled()) {
                getLog().debug("No changes to doc file: " + file);
            }
        } else {
            getLog().warn("No main doc file: " + file);
        }
    }

    protected void doResume() throws Exception {
         
        if (!initialized) {
            doStart();
        } else {
            if (listenerContainer != null) {
                startListenerContainer();
            } else {
                LOG.warn(
                        "The listenerContainer is not instantiated. Probably there was a timeout during the Suspend operation. Please restart your consumer route.");
            }
        }
    }

    protected void doStop() throws Exception {
        if (contextServicePlugins != null) {
            for (ContextServicePlugin plugin : contextServicePlugins) {
                try {
                    plugin.unload(camelContext);
                } catch (Exception e) {
                    LOG.warn(
                            "Unloading of plugin {} failed, however the exception will be ignored so shutdown can continue. Reason: {}",
                            plugin.getClass().getName(), e.getMessage(), e);
                }
            }
        }
    }

    public Sheets getClient(GoogleSheetsStreamConfiguration config) {
        if (client == null) {
            if (config.getClientId() != null && config.getClientSecret() != null) {
                client = getClientFactory().makeClient(config.getClientId(),
                        config.getClientSecret(), config.getScopesAsList(),
                        config.getApplicationName(), config.getRefreshToken(), config.getAccessToken());
            } else if (config.getServiceAccountKey() != null) {
                client = getClientFactory().makeClient(getCamelContext(), config.getServiceAccountKey(),
                        config.getScopesAsList(), config.getApplicationName(), config.getDelegate());
            } else {
                throw new IllegalArgumentException(
                        "(clientId and clientSecret) or serviceAccountKey are required to create Gmail client");
            }
        }
        return client;
    }

    public KeyPair rotateKey(String oldKeyId, String newKeyId, String algorithm) throws Exception {
        LOG.info("Rotating key from {} to {}", oldKeyId, newKeyId);

         
        KeyMetadata oldMetadata = getKeyMetadata(oldKeyId);
        if (oldMetadata == null) {
            throw new IllegalArgumentException("Old key not found: " + oldKeyId);
        }

         
        oldMetadata.setStatus(KeyMetadata.KeyStatus.DEPRECATED);
        updateKeyMetadata(oldKeyId, oldMetadata);

         
        KeyPair newKeyPair = generateKeyPair(algorithm, newKeyId);

        LOG.info("Key rotation completed in Vault: {} -> {}", oldKeyId, newKeyId);
        return newKeyPair;
    }

    protected void doStart() throws Exception {
        super.doStart();

        String accessKey = System.getenv(CAMEL_AWS_VAULT_ACCESS_KEY_ENV);
        String secretKey = System.getenv(CAMEL_AWS_VAULT_SECRET_KEY_ENV);
        String region = System.getenv(CAMEL_AWS_VAULT_REGION_ENV);
        boolean useDefaultCredentialsProvider
                = Boolean.parseBoolean(System.getenv(CAMEL_AWS_VAULT_USE_DEFAULT_CREDENTIALS_PROVIDER_ENV));
        boolean useProfileCredentialsProvider
                = Boolean.parseBoolean(System.getenv(CAMEL_AWS_VAULT_USE_PROFILE_CREDENTIALS_PROVIDER_ENV));
        String profileName = System.getenv(CAMEL_AWS_VAULT_PROFILE_NAME_ENV);
        boolean isOverrideEndpoint = Boolean.parseBoolean(System.getenv(CAMEL_AWS_VAULT_IS_OVERRIDE_ENDPOINT));
        String uriEndpointOverride = System.getenv(CAMEL_AWS_VAULT_URI_ENDPOINT_OVERRIDE);
        if (ObjectHelper.isEmpty(accessKey) && ObjectHelper.isEmpty(secretKey) && ObjectHelper.isEmpty(region)) {
            AwsVaultConfiguration awsVaultConfiguration = getCamelContext().getVaultConfiguration().aws();
            if (ObjectHelper.isNotEmpty(awsVaultConfiguration)) {
                accessKey = awsVaultConfiguration.getAccessKey();
                secretKey = awsVaultConfiguration.getSecretKey();
                region = awsVaultConfiguration.getRegion();
                useDefaultCredentialsProvider = awsVaultConfiguration.isDefaultCredentialsProvider();
                useProfileCredentialsProvider = awsVaultConfiguration.isProfileCredentialsProvider();
                profileName = awsVaultConfiguration.getProfileName();
                isOverrideEndpoint = awsVaultConfiguration.isOverrideEndpoint();
                uriEndpointOverride = awsVaultConfiguration.getUriEndpointOverride();
            }
        }
        this.region = region;
        if (ObjectHelper.isNotEmpty(accessKey) && ObjectHelper.isNotEmpty(secretKey) && ObjectHelper.isNotEmpty(region)) {
            SsmClientBuilder clientBuilder = SsmClient.builder();
            AwsBasicCredentials cred = AwsBasicCredentials.create(accessKey, secretKey);
            clientBuilder = clientBuilder.credentialsProvider(StaticCredentialsProvider.create(cred));
            clientBuilder.region(Region.of(region));
            if (isOverrideEndpoint) {
                if (ObjectHelper.isNotEmpty(uriEndpointOverride)) {
                    clientBuilder.endpointOverride(URI.create(uriEndpointOverride));
                }
            }
            client = clientBuilder.build();
        } else if (useDefaultCredentialsProvider && ObjectHelper.isNotEmpty(region)) {
            this.defaultCredentialsProvider = true;
            SsmClientBuilder clientBuilder = SsmClient.builder();
            clientBuilder.region(Region.of(region));
            if (isOverrideEndpoint) {
                if (ObjectHelper.isNotEmpty(uriEndpointOverride)) {
                    clientBuilder.endpointOverride(URI.create(uriEndpointOverride));
                }
            }
            client = clientBuilder.build();
        } else if (useProfileCredentialsProvider && ObjectHelper.isNotEmpty(profileName)) {
            this.profleCredentialsProvider = true;
            this.profileName = profileName;
            SsmClientBuilder clientBuilder = SsmClient.builder();
            clientBuilder.credentialsProvider(ProfileCredentialsProvider.create(profileName));
            clientBuilder.region(Region.of(region));
            if (isOverrideEndpoint) {
                if (ObjectHelper.isNotEmpty(uriEndpointOverride)) {
                    clientBuilder.endpointOverride(URI.create(uriEndpointOverride));
                }
            }
            client = clientBuilder.build();
        } else {
            throw new RuntimeCamelException(
                    "Using the AWS Parameter Store Properties Function requires setting AWS credentials as application properties or environment variables");
        }
    }

    protected JsonObject waitForOutputFile(Path outputFile) {
        StopWatch watch = new StopWatch();
        while (watch.taken() < timeout) {
            try {
                 
                Thread.sleep(20);

                if (Files.exists(outputFile)) {
                    String text = Files.readString(outputFile);
                    return (JsonObject) Jsoner.deserialize(text);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } catch (Exception e) {
                 
            }
        }
        return null;
    }

    public void configureOptions(CamelContext camelContext) {
        super.configureOptions(camelContext);

        PropertiesComponent propertiesComponent = camelContext.getPropertiesComponent();

        boolean oidcEnabled = Boolean.parseBoolean(
                propertiesComponent.resolveProperty(PROPERTY_PREFIX + "enabled").orElse("false"));
        setOidcEnabled(oidcEnabled);

        if (oidcEnabled) {
            Optional<String> oidcTokenPath = propertiesComponent.resolveProperty(PROPERTY_PREFIX + "token.path");
            oidcTokenPath.ifPresent(token -> this.oidcTokenPath = token);

            boolean renewTokenOnForbidden = Boolean.parseBoolean(
                    propertiesComponent.resolveProperty(PROPERTY_PREFIX + "renew.tokens.on.forbidden").orElse("true"));

            setRenewTokenOnForbidden(renewTokenOnForbidden);

            boolean cacheTokens = Boolean.parseBoolean(
                    propertiesComponent.resolveProperty(PROPERTY_PREFIX + "cache.tokens").orElse("true"));
            setCacheTokens(cacheTokens);
        }
    }

    public Drive getClient(GoogleDriveConfiguration config) {
        if (client == null) {
            if (config.getClientId() != null && !config.getClientId().isBlank()
                    && config.getClientSecret() != null && !config.getClientSecret().isBlank()) {
                client = getClientFactory().makeClient(config.getClientId(),
                        config.getClientSecret(), config.getScopesAsList(),
                        config.getApplicationName(), config.getRefreshToken(), config.getAccessToken());
            } else if (config.getServiceAccountKey() != null && !config.getServiceAccountKey().isBlank()) {
                client = getClientFactory().makeClient(getCamelContext(), config.getServiceAccountKey(),
                        config.getScopesAsList(), config.getApplicationName(), config.getDelegate());
            } else {
                throw new IllegalArgumentException(
                        "(clientId and clientSecret) or serviceAccountKey are required to create Google Drive client");
            }
        }
        return client;
    }

    protected String predict(Exchange exchange, QAInput input) {
        Model model = exchange.getContext().getRegistry().lookupByNameAndType(modelName, Model.class);
        @SuppressWarnings("unchecked")
        Translator<QAInput, String> translator
                = exchange.getContext().getRegistry().lookupByNameAndType(translatorName, Translator.class);

        exchange.getIn().setHeader(DJLConstants.INPUT, input);
        try (Predictor<QAInput, String> predictor = model.newPredictor(translator)) {
            return predictor.predict(input);
        } catch (TranslateException e) {
            throw new RuntimeCamelException("Could not process input or output", e);
        }
    }

    public boolean checkAfterSendProperties(Exchange exchange, Socket socket, Logger log) {
        final String logMessageFormat = "Exchange property {} = {} - {} connection";
        boolean answer = true;

        final boolean resetAfterSend
                = exchange.getProperty(MllpConstants.MLLP_RESET_CONNECTION_AFTER_SEND, false, boolean.class);
        if (resetAfterSend) {
            log.warn(logMessageFormat, MllpConstants.MLLP_RESET_CONNECTION_AFTER_SEND,
                    exchange.getProperty(MllpConstants.MLLP_RESET_CONNECTION_AFTER_SEND), "resetting");
            doConnectionClose(socket, true, log);
            answer = false;
        } else {
            final boolean closeAfterSend
                    = exchange.getProperty(MllpConstants.MLLP_CLOSE_CONNECTION_AFTER_SEND, false, boolean.class);
            if (closeAfterSend) {
                log.warn(logMessageFormat, MllpConstants.MLLP_CLOSE_CONNECTION_AFTER_SEND,
                        exchange.getProperty(MllpConstants.MLLP_CLOSE_CONNECTION_AFTER_SEND), "closing");
                doConnectionClose(socket, false, log);
                answer = false;
            }
        }

        return answer;
    }

    public SourceHandlerFactory getSourceHandlerFactory() {
        if (this.sourceHandlerFactory == null) {
            sourceHandlerFactoryLock.lock();
            try {
                if (this.sourceHandlerFactory == null) {
                    final XmlSourceHandlerFactoryImpl xmlSourceHandlerFactory = createXmlSourceHandlerFactoryImpl();
                    xmlSourceHandlerFactory.setFailOnNullBody(isFailOnNullBody());
                    this.sourceHandlerFactory = xmlSourceHandlerFactory;
                }
            } finally {
                sourceHandlerFactoryLock.unlock();
            }
        }

        return this.sourceHandlerFactory;
    }

    protected void doList(Exchange exchange) {
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        CronJobList cronJobList;

        if (ObjectHelper.isEmpty(namespace)) {
            cronJobList = getEndpoint().getKubernetesClient().batch().v1().cronjobs().inAnyNamespace().list();
        } else {
            cronJobList = getEndpoint().getKubernetesClient().batch().v1().cronjobs().inNamespace(namespace).list();
        }

        prepareOutboundMessage(exchange, cronJobList.getItems());
    }

    public void updateSObjectMultipart(
            String sObjectName, String id, Object sObjectDto, InputStream sObject,
            Map<String, List<String>> headers, ResponseCallback callback) {
        try {
            final Request patch = getRequest("PATCH", sobjectsUrl(sObjectName + "/" + id), headers);
            setAccessToken(patch);

            try (MultiPartRequestContent multipartContent = new MultiPartRequestContent()) {
                ObjectMapper objectMapper = new ObjectMapper();
                JsonNode jsonNode = objectMapper.readTree(sObject);

                if (jsonNode.isObject()) {
                    ObjectNode objectNode = (ObjectNode) jsonNode;
                    ObjectNode cleanJson = objectNode.deepCopy();

                    Map<String, InputStream> binaryFields = getBinaryFieldMap(sObjectDto);

                    if (!binaryFields.isEmpty()) {

                         
                        for (String fieldName : binaryFields.keySet()) {
                            cleanJson.remove(fieldName);
                        }

                         
                        String cleanJsonString = objectMapper.writeValueAsString(cleanJson);
                        multipartContent.addPart(new MultiPart.ContentSourcePart(
                                "entity", null,
                                HttpFields.build().add(HttpHeader.CONTENT_TYPE, APPLICATION_JSON_UTF8),
                                new InputStreamRequestContent(
                                        new ByteArrayInputStream(cleanJsonString.getBytes(StandardCharsets.UTF_8)))));

                         
                        for (Map.Entry<String, InputStream> entry : binaryFields.entrySet()) {
                            String fieldName = entry.getKey();
                            InputStream binaryData = entry.getValue();

                            multipartContent.addPart(new MultiPart.ContentSourcePart(
                                    fieldName, "temp-file-name.doc",
                                    HttpFields.build().add(HttpHeader.CONTENT_TYPE, "application/octet-stream"),
                                    new InputStreamRequestContent(binaryData)));
                        }
                    } else {
                         
                        callback.onResponse(null, Collections.emptyMap(),
                                new SalesforceException("updateSObjectMultipart called but no binary fields found", null));
                        return;
                    }
                } else {
                     
                    multipartContent.addPart(new MultiPart.ContentSourcePart(
                            "entity", null,
                            HttpFields.build().add(HttpHeader.CONTENT_TYPE, APPLICATION_JSON_UTF8),
                            new InputStreamRequestContent(sObject)));
                }

                patch.body(multipartContent);
            }

            doHttpRequest(patch, new DelegatingClientCallback(callback));
        } catch (Exception e) {
             
            callback.onResponse(null, Collections.emptyMap(),
                    new SalesforceException("Failed to process multipart update request: " + e.getMessage(), e));
        }
    }

    protected void doParse(Element element, BeanDefinitionBuilder builder) {
        NamedNodeMap attributes = element.getAttributes();
        for (int x = 0; x < attributes.getLength(); x++) {
            Attr attribute = (Attr) attributes.item(x);
            String name = attribute.getLocalName();
            String fullName = attribute.getName();
             
            if (fullName.equals("id") && isAssignId()) {
                if (attribute.getValue() != null) {
                    builder.addPropertyValue("id", attribute.getValue());
                }
                 
            } else if (!fullName.startsWith("xmlns:") && !fullName.equals("xmlns") && isEligibleAttribute(name)) {
                String propertyName = extractPropertyName(name);
                Assert.state(StringUtils.hasText(propertyName),
                        "Illegal property name returned from 'extractPropertyName(String)': cannot be null or empty.");
                builder.addPropertyValue(propertyName, attribute.getValue());
            }
        }
        postProcess(builder, element);
    }

    protected void prepareDataFormatConfig(Map<String, Object> properties) {
        properties.put("prettyPrint", definition.getPrettyPrint());
        properties.put("objectFactory", definition.getObjectFactory());
        properties.put("ignoreJAXBElement", definition.getIgnoreJAXBElement());
        properties.put("mustBeJAXBElement", definition.getMustBeJAXBElement());
        properties.put("filterNonXmlChars", definition.getFilterNonXmlChars());
        properties.put("fragment", definition.getFragment());
        properties.put("contextPath", definition.getContextPath());
        properties.put("contextPathIsClassName", definition.getContextPathIsClassName());
        properties.put("partClass", definition.getPartClass());
        properties.put("partNamespace", definition.getPartNamespace());
        properties.put("encoding", definition.getEncoding());
        properties.put("namespacePrefix", asRef(definition.getNamespacePrefix()));
        properties.put("schema", definition.getSchema());
        properties.put("schemaSeverityLevel", definition.getSchemaSeverityLevel());
        properties.put("xmlStreamWriterWrapper", definition.getXmlStreamWriterWrapper());
        properties.put("schemaLocation", definition.getSchemaLocation());
        properties.put("noNamespaceSchemaLocation", definition.getNoNamespaceSchemaLocation());
        properties.put("jaxbProviderProperties", definition.getJaxbProviderProperties());
        properties.put("accessExternalSchemaProtocols", definition.getAccessExternalSchemaProtocols());
    }

    public static String getEffectiveAddress(Exchange exchange, String defaultAddress) {
        String retval = exchange.getIn().getHeader(CxfConstants.DESTINATION_OVERRIDE_URL, String.class);
        if (retval == null) {
            retval = defaultAddress;
        } else {
            LOG.trace("Client address is overridden by header '{}' to value '{}'",
                    CxfConstants.DESTINATION_OVERRIDE_URL, retval);
        }
        return retval;
    }

    public String getString(final int index) {
        Object returnable = this.get(index);
        if (returnable instanceof Boolean) {
            returnable = returnable.toString();
        } else if (returnable instanceof Number) {
            returnable = returnable.toString();
        }
        return (String) returnable;
    }

    public static String extractTemplateId(CamelContext context, String remaining, Map<String, Object> parameters) {
        Object param = parameters.get(PARAM_TEMPLATE_ID);
        if (param != null) {
            return CamelContextHelper.mandatoryConvertTo(context, String.class, param);
        }

        if (SOURCE_ID.equals(remaining) || SINK_ID.equals(remaining)) {
            return context.resolvePropertyPlaceholders("{{" + PARAM_TEMPLATE_ID + "}}");
        }

        String answer = null;
        if (remaining != null) {
            answer = StringHelper.before(remaining, "/");
        }
        if (answer == null) {
            answer = remaining;
        }

        return answer;
    }

    public void setSchema(String schema) {
        if (ObjectHelper.isNotEmpty(schema)) {
            try {
                this.schema = ProtobufSchemaLoader.std.parse(schema);
            } catch (IOException e) {
                throw new RuntimeCamelException("Failed tp parse Protobuf schema", e);
            }
        } else {
            this.schema = null;
        }
    }

    public Expression createExpression(CamelContext camelContext, String expression) {
        Expression answer = null;
        if (block != null) {
            answer = block.createExpression(camelContext, expression);
        }
        if (answer == null) {
             
            answer = ExpressionBuilder.constantExpression("");
        }
        return answer;
    }

    protected <T> T cache(String name, Supplier<T> loader) {
        if (caching) {
            T t = (T) cache.get(name);
            if (t == null) {
                t = loader.get();
                if (t != null) {
                    cache.put(name, t);
                }
            }
            return t;
        } else {
            return loader.get();
        }
    }

    protected String doBuildCamelEndpointUri(String host, Integer port, String contextPath, String scheme) {
        if (!ObjectHelper.equal(scheme, "undertow")) {
            return super.doBuildCamelEndpointUri(host, port, contextPath, scheme);
        }

        String answer = scheme + ":http://" + host;
        if (port != null) {
            answer = answer + ":" + port;
        }

        if (contextPath != null) {
            if (!contextPath.startsWith("/")) {
                contextPath = "/" + contextPath;
            }

            answer += contextPath;
        }

        return answer;
    }

    public static boolean hasAnnotation(Class<?> cls, Class<? extends Annotation> annotation) {
        if (cls == null || cls == Object.class) {
            return false;
        }

        if (null != cls.getAnnotation(annotation)) {
            return true;
        }

        for (Class<?> interfaceClass : cls.getInterfaces()) {
            if (null != interfaceClass.getAnnotation(annotation)) {
                return true;
            }
        }
        return hasAnnotation(cls.getSuperclass(), annotation);
    }

    private void get(Exchange exchange) throws Exception {
        final Message in = exchange.getMessage();

        String collectionName = getCollectionName(in);
        Collection collection = this.client.getCollection(collectionName, embeddingFunction);

        List<String> ids = in.getHeader(ChromaHeaders.IDS, List.class);
        Map<String, String> where = in.getHeader(ChromaHeaders.WHERE, Map.class);
        Map<String, Object> whereDocument = in.getHeader(ChromaHeaders.WHERE_DOCUMENT, Map.class);

        Collection.GetResult result = collection.get(ids, where, whereDocument);

        in.setBody(result);
        in.setHeader(ChromaHeaders.OPERATION_STATUS, "SUCCESS");
    }

    public HttpServerInitializerFactory(NettyHttpConsumer nettyConsumer) {
        this.consumer = nettyConsumer;
        this.configuration = nettyConsumer.getConfiguration();
        try {
            this.sslContext = createSSLContext(consumer.getContext(), consumer.getConfiguration());
        } catch (Exception e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        }

        if (sslContext != null) {
            LOG.info("Created SslContext {}", sslContext);
        }
    }

    public boolean run(CamelContext camelContext, BooleanSupplier supplier) {
        running.set(true);
        boolean completed = false;

        TaskManagerRegistry registry = null;
        if (camelContext != null) {
            registry = PluginHelper.getTaskManagerRegistry(camelContext.getCamelContextExtension());
        }
        if (registry != null) {
            registry.addTask(this);
        }
        try {
            if (budget.initialDelay() > 0) {
                Thread.sleep(budget.initialDelay());
            }

            while (budget.next()) {
                lastAttemptTime = System.currentTimeMillis();
                if (firstAttemptTime < 0) {
                    firstAttemptTime = lastAttemptTime;
                }
                nextAttemptTime = lastAttemptTime + budget.interval();
                if (doRun(supplier)) {
                    LOG.debug("Task {} is complete after {} iterations and it is ready to continue",
                            getName(), budget.iteration());
                    status = Status.Completed;
                    completed = true;
                    break;
                }

                if (budget.canContinue()) {
                    Thread.sleep(budget.interval());
                } else {
                    status = Status.Exhausted;
                }
            }
        } catch (InterruptedException e) {
            LOG.warn("Interrupted {} while waiting for the repeatable task to finish", getName());
            Thread.currentThread().interrupt();
        } catch (Exception e) {
            status = Status.Failed;
            cause = e;
            throw e;
        } finally {
            elapsed = budget.elapsed();
            running.set(false);
            if (registry != null) {
                registry.removeTask(this);
            }
        }

        return completed;
    }

    private PropertiesFunction resolve(CamelContext context, String name) {
         
        Class<?> type = null;
        try {
            type = findFactory(name, context);
        } catch (Exception e) {
             
        }

        if (type != null) {
            if (LOG.isDebugEnabled()) {
                LOG.debug("Found PropertiesFunction: {} via: {}{}", type.getName(), factoryFinder.getResourcePath(), name);
            }
            if (PropertiesFunction.class.isAssignableFrom(type)) {
                PropertiesFunction answer = (PropertiesFunction) context.getInjector().newInstance(type, false);
                CamelContextAware.trySetCamelContext(answer, camelContext);
                ServiceHelper.startService(answer);
                return answer;
            } else {
                throw new IllegalArgumentException("Type is not a PropertiesFunction implementation. Found: " + type.getName());
            }
        }

        return null;
    }

    public String retrieveOidcToken() {
        if (oidcToken == null || !cacheTokens) {
            try {
                oidcToken = IOHelper
                        .loadText(ResourceHelper.resolveMandatoryResourceAsInputStream(getCamelContext(), oidcTokenPath))
                        .trim();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

        return oidcToken;
    }

    private void processStreamingRequest(
            InvokeModelWithResponseStreamRequest request,
            Exchange exchange) {

        try {
            String streamOutputMode = getConfiguration().getStreamOutputMode();
            if (streamOutputMode == null) {
                streamOutputMode = "complete";
            }

             
            if (ObjectHelper.isNotEmpty(exchange.getMessage().getHeader(BedrockConstants.STREAM_OUTPUT_MODE))) {
                streamOutputMode = exchange.getIn().getHeader(BedrockConstants.STREAM_OUTPUT_MODE, String.class);
            }

            Message message = getMessageForResponse(exchange);
            BedrockStreamHandler.StreamMetadata metadata = new BedrockStreamHandler.StreamMetadata();

            if ("chunks".equals(streamOutputMode)) {
                 
                List<String> allChunks = new ArrayList<>();
                getEndpoint().getBedrockRuntimeAsyncClient().invokeModelWithResponseStream(
                        request,
                        BedrockStreamHandler.createChunksHandler(
                                getConfiguration().getModelId(),
                                metadata,
                                allChunks,
                                null))
                        .join();

                message.setBody(allChunks);
                if (getConfiguration().isIncludeStreamingMetadata()) {
                    setStreamingMetadata(message, metadata);
                }
            } else {
                 
                StringBuilder fullText = new StringBuilder();
                getEndpoint().getBedrockRuntimeAsyncClient().invokeModelWithResponseStream(
                        request,
                        BedrockStreamHandler.createCompleteHandler(
                                getConfiguration().getModelId(),
                                metadata,
                                fullText))
                        .join();

                message.setBody(fullText.toString());
                if (getConfiguration().isIncludeStreamingMetadata()) {
                    setStreamingMetadata(message, metadata);
                }
            }

        } catch (AwsServiceException ase) {
            LOG.trace("Invoke Model Streaming command returned the error code {}", ase.awsErrorDetails().errorCode());
            throw ase;
        }
    }

    private <REQ, RES> void executeOperation(
            Exchange exchange,
            Class<REQ> requestClass,
            Function<REQ, RES> pojoExecutor,
            Supplier<RES> headerExecutor,
            String operationName,
            BiConsumer<RES, Message> responseProcessor)
            throws InvalidPayloadException {

        RES result;
        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (requestClass.isInstance(payload)) {
                try {
                    result = pojoExecutor.apply(requestClass.cast(payload));
                } catch (AwsServiceException ase) {
                    LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                    throw ase;
                }
            } else {
                throw new IllegalArgumentException(
                        String.format("Expected body of type %s but was %s",
                                requestClass.getName(),
                                payload != null ? payload.getClass().getName() : "null"));
            }
        } else {
            try {
                result = headerExecutor.get();
            } catch (AwsServiceException ase) {
                LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                throw ase;
            }
        }
        Message message = getMessageForResponse(exchange);
        message.setBody(result);
        if (responseProcessor != null) {
            responseProcessor.accept(result, message);
        }
    }

    public Map<String, Object> toMap() {
        JsonObject jo = new JsonObject();
        jo.put("alias", alias);
        if (aliasImplementation != null) {
            jo.put("aliasImplementation", aliasImplementation);
        }
        if (description != null) {
            jo.put("description", description);
        }
        if (serviceData != null) {
            jo.put("serviceData", serviceData);
        }
        return jo;
    }

    protected void doInit() throws Exception {
        super.doInit();

        try {
            RestConfiguration config = CamelContextHelper.getRestConfiguration(getCamelContext(), "servlet");

             
            if (config.getComponentProperties() != null && !config.getComponentProperties().isEmpty()) {
                setProperties(this, config.getComponentProperties());
            }
        } catch (IllegalArgumentException e) {
             
             
             
        }
    }

    public ServiceStatus getStatus() {
        switch (status) {
            case INITIALIZING:
                return ServiceStatus.Initializing;
            case INITIALIZED:
                return ServiceStatus.Initialized;
            case STARTING:
                return ServiceStatus.Starting;
            case STARTED:
                return ServiceStatus.Started;
            case SUSPENDING:
                return ServiceStatus.Suspending;
            case SUSPENDED:
                return ServiceStatus.Suspended;
            case STOPPING:
                return ServiceStatus.Stopping;
            default:
                return ServiceStatus.Stopped;
        }
    }

    public <T> ResultBuilder error(T data, ThrowingBiConsumer<ResultBuilder, T, Exception> consumer) {
        try {
            consumer.accept(this, data);
        } catch (NoSuchOptionException e) {
            error(ResultErrorBuilder.withMissingOption(e.getOptionName()).build());
        } catch (IllegalOptionException e) {
            error(ResultErrorBuilder.withIllegalOption(e.getOptionName(), e.getOptionValue()).build());
        } catch (Exception e) {
            error(ResultErrorBuilder.withException(e).build());
        }

        return this;
    }

    protected void doStart() throws Exception {
        super.doStart();

        if (getCamelContext().getPropertiesComponent().hasPropertiesFunction("azure")) {
            PropertiesFunction pf = getCamelContext().getPropertiesComponent().getPropertiesFunction("azure");
            if (pf instanceof KeyVaultPropertiesFunction) {
                propertiesFunction = (KeyVaultPropertiesFunction) pf;
            }
        }
        AzureVaultConfiguration azure = getCamelContext().getVaultConfiguration().getAzureVaultConfiguration();
        if (azure != null && azure.isRefreshEnabled()) {
            PeriodTaskScheduler scheduler = PluginHelper.getPeriodTaskScheduler(getCamelContext());
            secretsRefreshTask = scheduler.getTaskByType(EventhubsReloadTriggerTask.class);
        }
    }

    private void createBuildGradle(Path settings, Path gradleBuild, Set<String> deps) throws Exception {
        String[] ids = gav.split(":");

        InputStream is = ExportSpringBoot.class.getClassLoader().getResourceAsStream("templates/quarkus-build-gradle.tmpl");
        String context = IOHelper.loadText(is);
        IOHelper.close(is);

        Properties prop = new CamelCaseOrderedProperties();
        RuntimeUtil.loadProperties(prop, settings.toFile());
         
        String repos = getMavenRepositories(settings, prop, quarkusVersion);

        CamelCatalog catalog = CatalogLoader.loadQuarkusCatalog(repos, quarkusVersion, quarkusGroupId, download);
        if (camelVersion == null) {
            camelVersion = catalog.getCatalogVersion();
        }

        context = context.replaceFirst("\\{\\{ \\.GroupId }}", ids[0]);
        context = context.replaceFirst("\\{\\{ \\.ArtifactId }}", ids[1]);
        context = context.replaceFirst("\\{\\{ \\.Version }}", ids[2]);
        context = context.replaceFirst("\\{\\{ \\.QuarkusGroupId }}", quarkusGroupId);
        context = context.replaceFirst("\\{\\{ \\.QuarkusArtifactId }}", quarkusArtifactId);
        context = context.replaceAll("\\{\\{ \\.QuarkusVersion }}", quarkusVersion);
        context = context.replaceAll("\\{\\{ \\.JavaVersion }}", javaVersion);
        context = context.replaceAll("\\{\\{ \\.CamelVersion }}", camelVersion);

        if (repos == null || repos.isEmpty()) {
            context = context.replaceFirst("\\{\\{ \\.MavenRepositories }}", "");
        } else {
            StringBuilder sb = new StringBuilder();
            for (String repo : repos.split(",")) {
                sb.append("    maven {\n");
                sb.append("        url '").append(repo).append("'\n");
                if (repo.contains("snapshots")) {
                    sb.append("        mavenContent {\n");
                    sb.append("            snapshotsOnly()\n");
                    sb.append("        }\n");
                }
                sb.append("    }\n");
            }
            context = context.replaceFirst("\\{\\{ \\.MavenRepositories }}", sb.toString());
        }

        List<MavenGav> gavs = new ArrayList<>();
        for (String dep : deps) {
            MavenGav gav = parseMavenGav(dep);
            String gid = gav.getGroupId();
            String aid = gav.getArtifactId();
             
            if ("org.apache.camel".equals(gid)) {
                String qaid = aid.replace("camel-", "camel-quarkus-");
                ArtifactModel<?> am = catalog.modelFromMavenGAV("org.apache.camel.quarkus", qaid, null);
                if (am != null) {
                     
                    gav.setGroupId(am.getGroupId());
                    gav.setArtifactId(am.getArtifactId());
                    gav.setVersion(null);  
                } else {
                     
                    gav.setVersion(camelVersion);
                }
            }
            gavs.add(gav);
        }

         
        replaceQuarkusDependencies(gavs);

         
        gavs.sort(mavenGavComparator());

        StringBuilder sb = new StringBuilder();
        for (MavenGav gav : gavs) {
            if ("lib".equals(gav.getPackaging())) {
                 
                sb.append("    implementation files('lib/").append(gav.getArtifactId())
                        .append("-").append(gav.getVersion()).append(".jar')\n");
            } else if ("camel-kamelets-utils".equals(gav.getArtifactId())) {
                 
                sb.append("    implementation ('").append(gav).append("') {\n");
                sb.append("        exclude group: 'org.apache.camel', module: '*'\n");
                sb.append("    }\n");
            } else {
                sb.append("    implementation '").append(gav).append("'\n");
            }
        }
        context = context.replaceFirst("\\{\\{ \\.CamelDependencies }}", sb.toString());

        Files.writeString(gradleBuild, context);
    }

    private void addRoutePolicyFactories() {
        Map<String, RoutePolicyFactory> routePolicyFactories
                = getContext().getRegistry().findByTypeWithName(RoutePolicyFactory.class);
        if (routePolicyFactories != null && !routePolicyFactories.isEmpty()) {
            for (Entry<String, RoutePolicyFactory> entry : routePolicyFactories.entrySet()) {
                RoutePolicyFactory factory = entry.getValue();
                LOG.info("Using custom RoutePolicyFactory with id: {} and implementation: {}", entry.getKey(), factory);
                getContext().addRoutePolicyFactory(factory);
            }
        }
    }

    private void getIngestionJob(BedrockAgentClient bedrockAgentClient, Exchange exchange)
            throws InvalidPayloadException {
        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getMessage().getMandatoryBody();
            if (payload instanceof GetIngestionJobRequest) {
                GetIngestionJobResponse result;
                try {
                    result = bedrockAgentClient.getIngestionJob((GetIngestionJobRequest) payload);
                } catch (AwsServiceException ase) {
                    LOG.trace("Get Ingestion Job command returned the error code {}", ase.awsErrorDetails().errorCode());
                    throw ase;
                }
                Message message = getMessageForResponse(exchange);
                prepareGetIngestionJobResponse(result, message);
            }
        } else {
            String knowledgeBaseId;
            String dataSourceId;
            String ingestionJobId;
            GetIngestionJobRequest.Builder builder = GetIngestionJobRequest.builder();
            if (ObjectHelper.isEmpty(getConfiguration().getKnowledgeBaseId())) {
                if (ObjectHelper.isNotEmpty(exchange.getMessage().getHeader(BedrockAgentConstants.KNOWLEDGE_BASE_ID))) {
                    knowledgeBaseId = exchange.getMessage().getHeader(BedrockAgentConstants.KNOWLEDGE_BASE_ID, String.class);
                } else {
                    throw new IllegalArgumentException("KnowledgeBaseId must be specified");
                }
            } else {
                knowledgeBaseId = getConfiguration().getKnowledgeBaseId();
            }
            if (ObjectHelper.isEmpty(getConfiguration().getDataSourceId())) {
                if (ObjectHelper.isNotEmpty(exchange.getMessage().getHeader(BedrockAgentConstants.DATASOURCE_ID))) {
                    dataSourceId = exchange.getMessage().getHeader(BedrockAgentConstants.DATASOURCE_ID, String.class);
                } else {
                    throw new IllegalArgumentException("DataSourceId must be specified");
                }
            } else {
                dataSourceId = getConfiguration().getDataSourceId();
            }
            if (ObjectHelper.isEmpty(getConfiguration().getIngestionJobId())) {
                if (ObjectHelper.isNotEmpty(exchange.getMessage().getHeader(BedrockAgentConstants.INGESTION_JOB_ID))) {
                    ingestionJobId = exchange.getMessage().getHeader(BedrockAgentConstants.INGESTION_JOB_ID, String.class);
                } else {
                    throw new IllegalArgumentException("IngestionJobId must be specified");
                }
            } else {
                ingestionJobId = getConfiguration().getIngestionJobId();
            }
            builder.knowledgeBaseId(knowledgeBaseId);
            builder.dataSourceId(dataSourceId);
            builder.ingestionJobId(ingestionJobId);
            GetIngestionJobResponse output = bedrockAgentClient.getIngestionJob(builder.build());
            Message message = getMessageForResponse(exchange);
            prepareGetIngestionJobResponse(output, message);
        }
    }

    public void doInit() throws Exception {
        super.doInit();
        ProcessorFactory processorFactory;
        Resource schemaResource = ResourceHelper.resolveMandatoryResource(getCamelContext(), getSchemaUri());
        if (getRootElement() != null && !getRootElement().isEmpty() &&
                getRootNamespace() != null && !getRootNamespace().isEmpty()) {
            processorFactory
                    = Daffodil.compiler().compileSource(schemaResource.getURI(), getRootElement(), getRootNamespace());
        } else {
            processorFactory = Daffodil.compiler().compileSource(schemaResource.getURI());
        }
        if (processorFactory.isError()) {
            StringBuilder buf = new StringBuilder("Failed to start dfdl dataformat: [");
            for (Diagnostic d : processorFactory.getDiagnostics()) {
                buf.append(d.getMessage()).append("; ");
            }
            buf.append("]");
            throw new IOException(buf.toString());
        }
        this.daffodilProcessor = processorFactory.onPath("/");
    }

    private void runAsyncWaitContainer(Exchange exchange, Message message, DockerClient client) throws InterruptedException {
        try (WaitContainerCmd cmd = executeWaitContainerRequest(client, message)) {
            WaitContainerResultCallback item = cmd.exec(new WaitContainerResultCallback() {
                @Override
                public void onNext(WaitResponse item) {
                    super.onNext(item);

                    LOG.trace("wait container callback {}", item);
                }

            });

            setResponse(exchange, item);
        }
    }

    private void doCreateOrUpdateReplicationController(
            Exchange exchange, String operationName,
            Function<Resource<ReplicationController>, ReplicationController> operation) {
        String rcName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_REPLICATION_CONTROLLER_NAME, String.class);
        String namespaceName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        ReplicationControllerSpec rcSpec = exchange.getIn()
                .getHeader(KubernetesConstants.KUBERNETES_REPLICATION_CONTROLLER_SPEC, ReplicationControllerSpec.class);
        if (ObjectHelper.isEmpty(rcName)) {
            LOG.error("{} a specific replication controller require specify a replication controller name", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific replication controller require specify a replication controller name",
                            operationName));
        }
        if (ObjectHelper.isEmpty(namespaceName)) {
            LOG.error("{} a specific replication controller require specify a namespace name", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific replication controller require specify a namespace name", operationName));
        }
        if (ObjectHelper.isEmpty(rcSpec)) {
            LOG.error("{} a specific replication controller require specify a replication controller spec bean", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific replication controller require specify a replication controller spec bean",
                            operationName));
        }
        Map<String, String> labels
                = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_REPLICATION_CONTROLLERS_LABELS, Map.class);
        ReplicationController rcCreating = new ReplicationControllerBuilder().withNewMetadata().withName(rcName)
                .withLabels(labels).endMetadata().withSpec(rcSpec).build();
        ReplicationController rc
                = operation.apply(getEndpoint().getKubernetesClient().replicationControllers().inNamespace(namespaceName)
                        .resource(rcCreating));

        prepareOutboundMessage(exchange, rc);
    }

    public static Expression bodyOgnlExpression(final String ognl) {
        return new ExpressionAdapter() {
            private Language bean;

            @Override
            public Object evaluate(Exchange exchange) {
                Object body = exchange.getIn().getBody();
                if (body == null) {
                    return null;
                }
                Expression ognlExp = bean.createExpression(null, new Object[] { null, body, ognl });
                ognlExp.init(exchange.getContext());
                return ognlExp.evaluate(exchange, Object.class);
            }

            @Override
            public void init(CamelContext context) {
                bean = context.resolveLanguage("bean");
            }

            @Override
            public String toString() {
                return "bodyOgnl(" + ognl + ")";
            }
        };
    }

    public Processor createPreProcessor(Exchange exchange, DynamicAwareEntry entry) throws Exception {
        if (exchange.getMessage().getHeader(PahoConstants.CAMEL_PAHO_OVERRIDE_TOPIC) != null) {
            return null;
        }

        final String destinationName = parseTopicName(entry.getUri());
        return new Processor() {
            @Override
            public void process(Exchange exchange) throws Exception {
                exchange.getMessage().setHeader(PahoConstants.CAMEL_PAHO_OVERRIDE_TOPIC, destinationName);
            }
        };
    }

    private Object handlePaymentIntents(Exchange exchange, String method) throws Exception {
        switch (method) {
            case StripeConstants.METHOD_CREATE:
                return PaymentIntent.create(getParametersFromBody(exchange));
            case StripeConstants.METHOD_RETRIEVE:
                String id = exchange.getIn().getHeader(StripeConstants.OBJECT_ID, String.class);
                return PaymentIntent.retrieve(id);
            case StripeConstants.METHOD_UPDATE:
                String piId = exchange.getIn().getHeader(StripeConstants.OBJECT_ID, String.class);
                PaymentIntent pi = PaymentIntent.retrieve(piId);
                return pi.update(getParametersFromBody(exchange));
            case StripeConstants.METHOD_CANCEL:
                String cancelId = exchange.getIn().getHeader(StripeConstants.OBJECT_ID, String.class);
                PaymentIntent cancelPi = PaymentIntent.retrieve(cancelId);
                return cancelPi.cancel();
            case StripeConstants.METHOD_LIST:
                return PaymentIntent.list(getParametersFromBody(exchange));
            default:
                throw new IllegalArgumentException("Unsupported method for payment intents: " + method);
        }
    }

    public static void closeAllAsyncMdnServerConnections() {
        for (Map.Entry<Integer, AS2AsyncMDNServerConnection> entry : asyncMdnServerConnections.entrySet()) {
            try {
                int port = entry.getKey();
                LOG.debug("Stopping and closing AsyncMdnServerConnection on port: {}", port);
                entry.getValue().close();
            } catch (Exception e) {
                LOG.debug("Error stopping and closing AsyncMdnServerConnection due to {}. This exception is ignored",
                        e.getMessage(), e);
            }
        }
        asyncMdnServerConnections.clear();
    }

    private Function<Exchange, Object> findDocumentByKey() {
        return exchange -> {
            try {
                ArangoCollection collection = calculateDocumentCollection();
                 
                String key = exchange.getIn().getMandatoryBody(String.class);
                 
                Class<?> resultClassType = (Class<?>) exchange.getIn().getHeader(RESULT_CLASS_TYPE);
                resultClassType = resultClassType != null ? resultClassType : BaseDocument.class;

                return collection.getDocument(key, resultClassType);
            } catch (InvalidPayloadException e) {
                throw new RuntimeCamelException(INVALID_PAYLOAD_MESSAGE, e);
            }
        };
    }

    public ListPathsOptions getListPathOptions(final Exchange exchange) {
        ListPathsOptions pathsOptions = getListPathsOptions(exchange);

        if (ObjectHelper.isNotEmpty(pathsOptions)) {
            return pathsOptions;
        }

        pathsOptions = new ListPathsOptions();

        final String path = getPath(exchange);
        final Boolean recursive = isRecursive(exchange);
        final Integer maxResults = getMaxResults(exchange);
        final Boolean userPrincipalNameReturned = isUserPrincipalNameReturned(exchange);

        pathsOptions = pathsOptions.setPath(path).setMaxResults(maxResults).setRecursive(recursive)
                .setUserPrincipalNameReturned(userPrincipalNameReturned);
        return pathsOptions;
    }

    private void initFixedLengthRecordParameters() {

        for (Class<?> cl : models) {

             
            FixedLengthRecord fixedLengthRecord = cl.getAnnotation(FixedLengthRecord.class);

            if (fixedLengthRecord != null) {
                LOG.debug("Fixed length record: {}", fixedLengthRecord);

                 
                crlf = fixedLengthRecord.crlf();
                LOG.debug("Carriage return defined for the CSV: {}", crlf);

                eol = fixedLengthRecord.eol();
                LOG.debug("EOL(end-of-line) defined for the CSV: {}", eol);

                 
                header = fixedLengthRecord.header();
                LOG.debug("Header: {}", header);
                hasHeader = header != void.class;
                LOG.debug("Has Header: {}", hasHeader);

                 
                skipHeader = fixedLengthRecord.skipHeader();
                LOG.debug("Skip Header: {}", skipHeader);

                 
                footer = fixedLengthRecord.footer();
                LOG.debug("Footer: {}", footer);
                hasFooter = fixedLengthRecord.footer() != void.class;
                LOG.debug("Has Footer: {}", hasFooter);

                 
                skipFooter = fixedLengthRecord.skipFooter();
                LOG.debug("Skip Footer: {}", skipFooter);

                 
                isHeader = hasHeader && cl.equals(header);
                LOG.debug("Is Header: {}", isHeader);

                 
                isFooter = hasFooter && cl.equals(footer);
                LOG.debug("Is Footer: {}", isFooter);

                 
                paddingChar = fixedLengthRecord.paddingChar();
                LOG.debug("Padding char: {}", paddingChar);

                 
                recordLength = fixedLengthRecord.length();
                LOG.debug("Length of the record: {}", recordLength);

                 
                ignoreTrailingChars = fixedLengthRecord.ignoreTrailingChars();
                LOG.debug("Ignore trailing chars: {}", ignoreTrailingChars);

                ignoreMissingChars = fixedLengthRecord.ignoreMissingChars();
                LOG.debug("Enable ignore missing chars: {}", ignoreMissingChars);

                countGrapheme = fixedLengthRecord.countGrapheme();
                LOG.debug("Enable grapheme counting instead of codepoints: {}", countGrapheme);
            }
        }

        if (hasHeader && isHeader) {
            throw new java.lang.IllegalArgumentException(
                    "Record can not be configured with both 'isHeader=true' and 'hasHeader=true'");
        }

        if (hasFooter && isFooter) {
            throw new java.lang.IllegalArgumentException(
                    "Record can not be configured with both 'isFooter=true' and 'hasFooter=true'");
        }

        if ((isHeader || isFooter) && (skipHeader || skipFooter)) {
            throw new java.lang.IllegalArgumentException(
                    "skipHeader and/or skipFooter can not be configured on a record where 'isHeader=true' or 'isFooter=true'");
        }

    }

            private String extractState(int status) {
                if (status <= 4) {
                    return "Starting";
                } else if (status == 5) {
                    return "Running";
                } else if (status == 6) {
                    return "Suspending";
                } else if (status == 7) {
                    return "Suspended";
                } else if (status == 8) {
                    return "Terminating";
                } else if (status == 9) {
                    return "Terminated";
                } else {
                    return "Terminated";
                }
            }

    private void processGetReportDescription(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {

        final String reportId = getParameter(REPORT_ID, exchange, USE_BODY, NOT_OPTIONAL);

        analyticsClient.getReportDescription(reportId, determineHeaders(exchange),
                new AnalyticsApiClient.ReportDescriptionResponseCallback() {
                    @Override
                    public void onResponse(
                            ReportDescription reportDescription, Map<String, String> headers, SalesforceException ex) {
                        processResponse(exchange, reportDescription, headers, ex, callback);
                    }
                });
    }

    private static void resolveGistAsRawFiles(
            String url, StringJoiner routes, StringJoiner kamelets, StringJoiner properties, StringJoiner all)
            throws Exception {

         
        HttpClient hc = HttpClient.newHttpClient();
        HttpResponse<String> res = hc.send(HttpRequest.newBuilder(new URI(url)).timeout(Duration.ofSeconds(20)).build(),
                HttpResponse.BodyHandlers.ofString());

        if (res.statusCode() == 200) {
            ObjectMapper mapper = new ObjectMapper();
            JsonNode root = mapper.readTree(res.body());
            for (JsonNode c : root.get("files")) {
                String name = c.get("filename").asText();
                String ext = FileUtil.onlyExt(name, false);
                if (kamelets != null && "kamelet.yaml".equalsIgnoreCase(ext)) {
                    String rawUrl = c.get("raw_url").asText();
                    String u = asGistSingleUrl(rawUrl);
                    kamelets.add(u);
                } else if (properties != null && "properties".equalsIgnoreCase(ext)) {
                    String rawUrl = c.get("raw_url").asText();
                    String u = asGistSingleUrl(rawUrl);
                    properties.add(u);
                } else if (routes != null) {
                    if ("java".equalsIgnoreCase(ext) || "xml".equalsIgnoreCase(ext)
                            || "yaml".equalsIgnoreCase(ext) || "camel.yaml".equalsIgnoreCase(ext)) {
                        String rawUrl = c.get("raw_url").asText();
                        String u = asGistSingleUrl(rawUrl);
                        routes.add(u);
                    }
                } else if (all != null) {
                    String rawUrl = c.get("raw_url").asText();
                    String u = asGistSingleUrl(rawUrl);
                    all.add(u);
                }
            }
        }
    }

    public Object remove(Object key) {
        lock.lock();
        try {
            locations.remove(key);
            defaultValues.remove(key);
            return super.remove(key);
        } finally {
            lock.unlock();
        }
    }

    protected void doDeleteTag(String operation) throws GitAPIException {
        if (ObjectHelper.isEmpty(endpoint.getTagName())) {
            throw new IllegalArgumentException("Tag Name must be specified to execute " + operation);
        }
        try {
            git.tagDelete().setTags(endpoint.getTagName()).call();
        } catch (GitAPIException e) {
            LOG.error("There was an error in Git {} operation", operation);
            throw e;
        }
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        OpenAIConfiguration configuration = new OpenAIConfiguration();

        if (apiKey != null) {
            configuration.setApiKey(apiKey);
        }
        if (baseUrl != null) {
            configuration.setBaseUrl(baseUrl);
        }
        if (model != null) {
            configuration.setModel(model);
        }

        OpenAIEndpoint endpoint = new OpenAIEndpoint(uri, this, configuration);
         
        endpoint.setOperation(remaining);
        setProperties(endpoint, parameters);

        return endpoint;
    }

    private static List<String> getDependencies(Object kamelet) throws Exception {
        List<String> answer = new ArrayList<>();
        Method m = kamelet.getClass().getMethod("getSpec");
        Object spec = ObjectHelper.invokeMethod(m, kamelet);
        m = spec.getClass().getMethod("getDependencies");
        @SuppressWarnings("unchecked")
        List<Object> list = (List<Object>) ObjectHelper.invokeMethod(m, spec);
        if (list != null && !list.isEmpty()) {
            for (var en : list) {
                String t = en.toString();
                t = StringHelper.removeLeadingAndEndingQuotes(t);
                answer.add(t);
            }
        }
        return answer.isEmpty() ? null : answer;
    }

    public boolean acquireExclusiveReadLock(GenericFileOperations<File> operations, GenericFile<File> file, Exchange exchange)
            throws Exception {
         
         
        File path = file.getFile();
        if (!path.exists()) {
            return false;
        }

         
        String key = asKey(exchange, file);
        boolean answer = false;
        try {
            answer = idempotentRepository.add(exchange, key);
        } catch (Exception e) {
            if (LOG.isTraceEnabled()) {
                LOG.trace("Cannot acquire read lock due to {}. Will skip the file: {}", e.getMessage(), file, e);
            }
        }
        if (!answer) {
             
            CamelLogger.log(LOG, readLockLoggingLevel, "Cannot acquire read lock. Will skip the file: " + file);
        }
        return answer;
    }

    protected String asTypeName(Class<?> classType) {
         
         
         
         
         
         
         
         

        String type;

        if (classType.isArray()) {
            type = classType.getComponentType().getName() + "[]";
        } else {
            type = classType.getName();
        }

        return type;
    }

    public void getReportDescription(
            String reportId, final Map<String, List<String>> headers, final ReportDescriptionResponseCallback callback) {

        final Request request = getRequest(HttpMethod.GET, reportsDescribeUrl(reportId), headers);

        doHttpRequest(request, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                ReportDescription reportDescription = null;
                try {
                    reportDescription = unmarshalResponse(response, request, ReportDescription.class);
                } catch (SalesforceException e) {
                    ex = e;
                }
                callback.onResponse(reportDescription, headers, ex);
            }
        });
    }

    public String getLastChosenProcessorId() {
        int idx = getProcessor().getLastChosenProcessorIndex();
        if (idx != -1) {
            LoadBalanceDefinition def = getDefinition();
            ProcessorDefinition<?> output = def.getOutputs().get(idx);
            if (output != null) {
                return output.getId();
            }
        }
        return null;
    }

    private void describeDeliveryStream(FirehoseClient client, Exchange exchange) throws InvalidPayloadException {
        executeOperation(
                exchange,
                DescribeDeliveryStreamRequest.class,
                client::describeDeliveryStream,
                () -> {
                    String streamName = getOptionalHeader(exchange, KinesisFirehose2Constants.KINESIS_FIREHOSE_STREAM_NAME,
                            String.class);
                    if (streamName == null) {
                        throw new IllegalArgumentException(
                                "The describeDeliveryStream operation expects at least a delivery stream name header or a DescribeDeliveryStreamRequest instance");
                    }
                    return client.describeDeliveryStream(
                            DescribeDeliveryStreamRequest.builder().deliveryStreamName(streamName).build());
                },
                "describeDeliveryStream",
                (DescribeDeliveryStreamResponse response, Message message) -> {
                    if (response.deliveryStreamDescription() != null) {
                        message.setHeader(KinesisFirehose2Constants.DELIVERY_STREAM_ARN,
                                response.deliveryStreamDescription().deliveryStreamARN());
                        message.setHeader(KinesisFirehose2Constants.DELIVERY_STREAM_STATUS,
                                response.deliveryStreamDescription().deliveryStreamStatusAsString());
                    }
                });
    }

        protected boolean setPropertyOnComponent(
                Component component,
                String name,
                Object value) {
            switch (name) {
            case "additionalProperties": getOrCreateConfiguration((KafkaComponent) component).setAdditionalProperties((java.util.Map) value); return true;
            case "brokers": getOrCreateConfiguration((KafkaComponent) component).setBrokers((java.lang.String) value); return true;
            case "clientId": getOrCreateConfiguration((KafkaComponent) component).setClientId((java.lang.String) value); return true;
            case "configuration": ((KafkaComponent) component).setConfiguration((org.apache.camel.component.kafka.KafkaConfiguration) value); return true;
            case "headerFilterStrategy": getOrCreateConfiguration((KafkaComponent) component).setHeaderFilterStrategy((org.apache.camel.spi.HeaderFilterStrategy) value); return true;
            case "reconnectBackoffMaxMs": getOrCreateConfiguration((KafkaComponent) component).setReconnectBackoffMaxMs((java.lang.Integer) value); return true;
            case "retryBackoffMaxMs": getOrCreateConfiguration((KafkaComponent) component).setRetryBackoffMaxMs((java.lang.Integer) value); return true;
            case "retryBackoffMs": getOrCreateConfiguration((KafkaComponent) component).setRetryBackoffMs((java.lang.Integer) value); return true;
            case "shutdownTimeout": getOrCreateConfiguration((KafkaComponent) component).setShutdownTimeout((int) value); return true;
            case "allowManualCommit": getOrCreateConfiguration((KafkaComponent) component).setAllowManualCommit((boolean) value); return true;
            case "autoCommitEnable": getOrCreateConfiguration((KafkaComponent) component).setAutoCommitEnable((boolean) value); return true;
            case "autoCommitIntervalMs": getOrCreateConfiguration((KafkaComponent) component).setAutoCommitIntervalMs((java.lang.Integer) value); return true;
            case "autoOffsetReset": getOrCreateConfiguration((KafkaComponent) component).setAutoOffsetReset((java.lang.String) value); return true;
            case "batching": getOrCreateConfiguration((KafkaComponent) component).setBatching((boolean) value); return true;
            case "batchingIntervalMs": getOrCreateConfiguration((KafkaComponent) component).setBatchingIntervalMs((java.lang.Integer) value); return true;
            case "breakOnFirstError": getOrCreateConfiguration((KafkaComponent) component).setBreakOnFirstError((boolean) value); return true;
            case "bridgeErrorHandler": ((KafkaComponent) component).setBridgeErrorHandler((boolean) value); return true;
            case "checkCrcs": getOrCreateConfiguration((KafkaComponent) component).setCheckCrcs((java.lang.Boolean) value); return true;
            case "commitTimeoutMs": getOrCreateConfiguration((KafkaComponent) component).setCommitTimeoutMs((java.lang.Long) value); return true;
            case "consumerRequestTimeoutMs": getOrCreateConfiguration((KafkaComponent) component).setConsumerRequestTimeoutMs((java.lang.Integer) value); return true;
            case "consumersCount": getOrCreateConfiguration((KafkaComponent) component).setConsumersCount((int) value); return true;
            case "fetchMaxBytes": getOrCreateConfiguration((KafkaComponent) component).setFetchMaxBytes((java.lang.Integer) value); return true;
            case "fetchMinBytes": getOrCreateConfiguration((KafkaComponent) component).setFetchMinBytes((java.lang.Integer) value); return true;
            case "fetchWaitMaxMs": getOrCreateConfiguration((KafkaComponent) component).setFetchWaitMaxMs((java.lang.Integer) value); return true;
            case "groupId": getOrCreateConfiguration((KafkaComponent) component).setGroupId((java.lang.String) value); return true;
            case "groupInstanceId": getOrCreateConfiguration((KafkaComponent) component).setGroupInstanceId((java.lang.String) value); return true;
            case "headerDeserializer": getOrCreateConfiguration((KafkaComponent) component).setHeaderDeserializer((org.apache.camel.component.kafka.serde.KafkaHeaderDeserializer) value); return true;
            case "heartbeatIntervalMs": getOrCreateConfiguration((KafkaComponent) component).setHeartbeatIntervalMs((java.lang.Integer) value); return true;
            case "keyDeserializer": getOrCreateConfiguration((KafkaComponent) component).setKeyDeserializer((java.lang.String) value); return true;
            case "maxPartitionFetchBytes": getOrCreateConfiguration((KafkaComponent) component).setMaxPartitionFetchBytes((java.lang.Integer) value); return true;
            case "maxPollIntervalMs": getOrCreateConfiguration((KafkaComponent) component).setMaxPollIntervalMs((java.lang.Integer) value); return true;
            case "maxPollRecords": getOrCreateConfiguration((KafkaComponent) component).setMaxPollRecords((java.lang.Integer) value); return true;
            case "offsetRepository": getOrCreateConfiguration((KafkaComponent) component).setOffsetRepository((org.apache.camel.spi.StateRepository) value); return true;
            case "partitionAssignor": getOrCreateConfiguration((KafkaComponent) component).setPartitionAssignor((java.lang.String) value); return true;
            case "pollOnError": getOrCreateConfiguration((KafkaComponent) component).setPollOnError((org.apache.camel.component.kafka.PollOnError) value); return true;
            case "pollTimeoutMs": getOrCreateConfiguration((KafkaComponent) component).setPollTimeoutMs((java.lang.Long) value); return true;
            case "preValidateHostAndPort": getOrCreateConfiguration((KafkaComponent) component).setPreValidateHostAndPort((boolean) value); return true;
            case "seekTo": getOrCreateConfiguration((KafkaComponent) component).setSeekTo((org.apache.camel.component.kafka.SeekPolicy) value); return true;
            case "sessionTimeoutMs": getOrCreateConfiguration((KafkaComponent) component).setSessionTimeoutMs((java.lang.Integer) value); return true;
            case "specificAvroReader": getOrCreateConfiguration((KafkaComponent) component).setSpecificAvroReader((boolean) value); return true;
            case "topicIsPattern": getOrCreateConfiguration((KafkaComponent) component).setTopicIsPattern((boolean) value); return true;
            case "valueDeserializer": getOrCreateConfiguration((KafkaComponent) component).setValueDeserializer((java.lang.String) value); return true;
            case "createConsumerBackoffInterval": ((KafkaComponent) component).setCreateConsumerBackoffInterval((long) value); return true;
            case "createConsumerBackoffMaxAttempts": ((KafkaComponent) component).setCreateConsumerBackoffMaxAttempts((int) value); return true;
            case "isolationLevel": getOrCreateConfiguration((KafkaComponent) component).setIsolationLevel((java.lang.String) value); return true;
            case "kafkaManualCommitFactory": ((KafkaComponent) component).setKafkaManualCommitFactory((org.apache.camel.component.kafka.consumer.KafkaManualCommitFactory) value); return true;
            case "pollExceptionStrategy": ((KafkaComponent) component).setPollExceptionStrategy((org.apache.camel.component.kafka.PollExceptionStrategy) value); return true;
            case "subscribeConsumerBackoffInterval": ((KafkaComponent) component).setSubscribeConsumerBackoffInterval((long) value); return true;
            case "subscribeConsumerBackoffMaxAttempts": ((KafkaComponent) component).setSubscribeConsumerBackoffMaxAttempts((int) value); return true;
            case "subscribeConsumerTopicMustExists": ((KafkaComponent) component).setSubscribeConsumerTopicMustExists((boolean) value); return true;
            case "batchWithIndividualHeaders": getOrCreateConfiguration((KafkaComponent) component).setBatchWithIndividualHeaders((boolean) value); return true;
            case "bufferMemorySize": getOrCreateConfiguration((KafkaComponent) component).setBufferMemorySize((java.lang.Integer) value); return true;
            case "compressionCodec": getOrCreateConfiguration((KafkaComponent) component).setCompressionCodec((java.lang.String) value); return true;
            case "connectionMaxIdleMs": getOrCreateConfiguration((KafkaComponent) component).setConnectionMaxIdleMs((java.lang.Integer) value); return true;
            case "deliveryTimeoutMs": getOrCreateConfiguration((KafkaComponent) component).setDeliveryTimeoutMs((java.lang.Integer) value); return true;
            case "enableIdempotence": getOrCreateConfiguration((KafkaComponent) component).setEnableIdempotence((boolean) value); return true;
            case "headerSerializer": getOrCreateConfiguration((KafkaComponent) component).setHeaderSerializer((org.apache.camel.component.kafka.serde.KafkaHeaderSerializer) value); return true;
            case "key": getOrCreateConfiguration((KafkaComponent) component).setKey((java.lang.String) value); return true;
            case "keySerializer": getOrCreateConfiguration((KafkaComponent) component).setKeySerializer((java.lang.String) value); return true;
            case "lazyStartProducer": ((KafkaComponent) component).setLazyStartProducer((boolean) value); return true;
            case "lingerMs": getOrCreateConfiguration((KafkaComponent) component).setLingerMs((java.lang.Integer) value); return true;
            case "maxBlockMs": getOrCreateConfiguration((KafkaComponent) component).setMaxBlockMs((java.lang.Integer) value); return true;
            case "maxInFlightRequest": getOrCreateConfiguration((KafkaComponent) component).setMaxInFlightRequest((java.lang.Integer) value); return true;
            case "maxRequestSize": getOrCreateConfiguration((KafkaComponent) component).setMaxRequestSize((java.lang.Integer) value); return true;
            case "metadataMaxAgeMs": getOrCreateConfiguration((KafkaComponent) component).setMetadataMaxAgeMs((java.lang.Integer) value); return true;
            case "metricReporters": getOrCreateConfiguration((KafkaComponent) component).setMetricReporters((java.lang.String) value); return true;
            case "metricsSampleWindowMs": getOrCreateConfiguration((KafkaComponent) component).setMetricsSampleWindowMs((java.lang.Integer) value); return true;
            case "noOfMetricsSample": getOrCreateConfiguration((KafkaComponent) component).setNoOfMetricsSample((java.lang.Integer) value); return true;
            case "partitioner": getOrCreateConfiguration((KafkaComponent) component).setPartitioner((java.lang.String) value); return true;
            case "partitionerIgnoreKeys": getOrCreateConfiguration((KafkaComponent) component).setPartitionerIgnoreKeys((boolean) value); return true;
            case "partitionKey": getOrCreateConfiguration((KafkaComponent) component).setPartitionKey((java.lang.Integer) value); return true;
            case "producerBatchSize": getOrCreateConfiguration((KafkaComponent) component).setProducerBatchSize((java.lang.Integer) value); return true;
            case "queueBufferingMaxMessages": getOrCreateConfiguration((KafkaComponent) component).setQueueBufferingMaxMessages((java.lang.Integer) value); return true;
            case "receiveBufferBytes": getOrCreateConfiguration((KafkaComponent) component).setReceiveBufferBytes((java.lang.Integer) value); return true;
            case "reconnectBackoffMs": getOrCreateConfiguration((KafkaComponent) component).setReconnectBackoffMs((java.lang.Integer) value); return true;
            case "requestRequiredAcks": getOrCreateConfiguration((KafkaComponent) component).setRequestRequiredAcks((java.lang.String) value); return true;
            case "requestTimeoutMs": getOrCreateConfiguration((KafkaComponent) component).setRequestTimeoutMs((java.lang.Integer) value); return true;
            case "retries": getOrCreateConfiguration((KafkaComponent) component).setRetries((java.lang.Integer) value); return true;
            case "sendBufferBytes": getOrCreateConfiguration((KafkaComponent) component).setSendBufferBytes((java.lang.Integer) value); return true;
            case "transacted": getOrCreateConfiguration((KafkaComponent) component).setTransacted((boolean) value); return true;
            case "transactionalId": getOrCreateConfiguration((KafkaComponent) component).setTransactionalId((java.lang.String) value); return true;
            case "useIterator": getOrCreateConfiguration((KafkaComponent) component).setUseIterator((boolean) value); return true;
            case "valueSerializer": getOrCreateConfiguration((KafkaComponent) component).setValueSerializer((java.lang.String) value); return true;
            case "workerPool": getOrCreateConfiguration((KafkaComponent) component).setWorkerPool((java.util.concurrent.ExecutorService) value); return true;
            case "workerPoolCoreSize": getOrCreateConfiguration((KafkaComponent) component).setWorkerPoolCoreSize((java.lang.Integer) value); return true;
            case "workerPoolMaxSize": getOrCreateConfiguration((KafkaComponent) component).setWorkerPoolMaxSize((java.lang.Integer) value); return true;
            case "recordMetadata": getOrCreateConfiguration((KafkaComponent) component).setRecordMetadata((boolean) value); return true;
            case "autowiredEnabled": ((KafkaComponent) component).setAutowiredEnabled((boolean) value); return true;
            case "kafkaClientFactory": ((KafkaComponent) component).setKafkaClientFactory((org.apache.camel.component.kafka.KafkaClientFactory) value); return true;
            case "synchronous": getOrCreateConfiguration((KafkaComponent) component).setSynchronous((boolean) value); return true;
            case "healthCheckConsumerEnabled": ((KafkaComponent) component).setHealthCheckConsumerEnabled((boolean) value); return true;
            case "healthCheckProducerEnabled": ((KafkaComponent) component).setHealthCheckProducerEnabled((boolean) value); return true;
            case "interceptorClasses": getOrCreateConfiguration((KafkaComponent) component).setInterceptorClasses((java.lang.String) value); return true;
            case "schemaRegistryURL": getOrCreateConfiguration((KafkaComponent) component).setSchemaRegistryURL((java.lang.String) value); return true;
            case "kerberosBeforeReloginMinTime": getOrCreateConfiguration((KafkaComponent) component).setKerberosBeforeReloginMinTime((java.lang.Integer) value); return true;
            case "kerberosConfigLocation": getOrCreateConfiguration((KafkaComponent) component).setKerberosConfigLocation((java.lang.String) value); return true;
            case "kerberosInitCmd": getOrCreateConfiguration((KafkaComponent) component).setKerberosInitCmd((java.lang.String) value); return true;
            case "kerberosPrincipalToLocalRules": getOrCreateConfiguration((KafkaComponent) component).setKerberosPrincipalToLocalRules((java.lang.String) value); return true;
            case "kerberosRenewJitter": getOrCreateConfiguration((KafkaComponent) component).setKerberosRenewJitter((java.lang.Double) value); return true;
            case "kerberosRenewWindowFactor": getOrCreateConfiguration((KafkaComponent) component).setKerberosRenewWindowFactor((java.lang.Double) value); return true;
            case "saslJaasConfig": getOrCreateConfiguration((KafkaComponent) component).setSaslJaasConfig((java.lang.String) value); return true;
            case "saslKerberosServiceName": getOrCreateConfiguration((KafkaComponent) component).setSaslKerberosServiceName((java.lang.String) value); return true;
            case "saslMechanism": getOrCreateConfiguration((KafkaComponent) component).setSaslMechanism((java.lang.String) value); return true;
            case "securityProtocol": getOrCreateConfiguration((KafkaComponent) component).setSecurityProtocol((java.lang.String) value); return true;
            case "sslCipherSuites": getOrCreateConfiguration((KafkaComponent) component).setSslCipherSuites((java.lang.String) value); return true;
            case "sslContextParameters": getOrCreateConfiguration((KafkaComponent) component).setSslContextParameters((org.apache.camel.support.jsse.SSLContextParameters) value); return true;
            case "sslEnabledProtocols": getOrCreateConfiguration((KafkaComponent) component).setSslEnabledProtocols((java.lang.String) value); return true;
            case "sslEndpointAlgorithm": getOrCreateConfiguration((KafkaComponent) component).setSslEndpointAlgorithm((java.lang.String) value); return true;
            case "sslKeymanagerAlgorithm": getOrCreateConfiguration((KafkaComponent) component).setSslKeymanagerAlgorithm((java.lang.String) value); return true;
            case "sslKeyPassword": getOrCreateConfiguration((KafkaComponent) component).setSslKeyPassword((java.lang.String) value); return true;
            case "sslKeystoreLocation": getOrCreateConfiguration((KafkaComponent) component).setSslKeystoreLocation((java.lang.String) value); return true;
            case "sslKeystorePassword": getOrCreateConfiguration((KafkaComponent) component).setSslKeystorePassword((java.lang.String) value); return true;
            case "sslKeystoreType": getOrCreateConfiguration((KafkaComponent) component).setSslKeystoreType((java.lang.String) value); return true;
            case "sslProtocol": getOrCreateConfiguration((KafkaComponent) component).setSslProtocol((java.lang.String) value); return true;
            case "sslProvider": getOrCreateConfiguration((KafkaComponent) component).setSslProvider((java.lang.String) value); return true;
            case "sslTrustmanagerAlgorithm": getOrCreateConfiguration((KafkaComponent) component).setSslTrustmanagerAlgorithm((java.lang.String) value); return true;
            case "sslTruststoreLocation": getOrCreateConfiguration((KafkaComponent) component).setSslTruststoreLocation((java.lang.String) value); return true;
            case "sslTruststorePassword": getOrCreateConfiguration((KafkaComponent) component).setSslTruststorePassword((java.lang.String) value); return true;
            case "sslTruststoreType": getOrCreateConfiguration((KafkaComponent) component).setSslTruststoreType((java.lang.String) value); return true;
            case "useGlobalSslContextParameters": ((KafkaComponent) component).setUseGlobalSslContextParameters((boolean) value); return true;
            default: return false;
            }
        }

    public static void configureConnects(Traits traitsSpec, String[] connects) {
        if (connects == null || connects.length == 0) {
            return;
        }
        ServiceBinding serviceBindingTrait = Optional.ofNullable(traitsSpec.getServiceBinding()).orElseGet(ServiceBinding::new);
        if (serviceBindingTrait.getServices() == null) {
            serviceBindingTrait.setServices(new ArrayList<>());
        }
        serviceBindingTrait.getServices().addAll(List.of(connects));
        traitsSpec.setServiceBinding(serviceBindingTrait);
    }

    private void processCloseJob(Exchange exchange, AsyncCallback callback)
            throws SalesforceException {
        String jobId = getParameter(JOB_ID, exchange, IGNORE_BODY, NOT_OPTIONAL);
        bulkClient.changeJobState(jobId, JobStateEnum.UPLOAD_COMPLETE, determineHeaders(exchange),
                new JobResponseCallback() {
                    @Override
                    public void onResponse(Job job, Map<String, String> headers, SalesforceException ex) {
                        processResponse(exchange, job, headers, ex, callback);
                    }
                });
    }

        void cleanUpTempFile() {
             
            try {
                if (tempFile != null) {
                    FileUtil.deleteFile(tempFile);
                    tempFile = null;
                }
            } catch (Exception e) {
                LOG.warn("Error deleting temporary cache file: {}. This exception will be ignored.", tempFile, e);
            }
        }

    private void updateGroup(Exchange exchange, ClientConfigurations clientConfigurations) {
         
        Object body = exchange.getMessage().getBody();
        KeystoneUpdateGroupOption groupOption;
        if (body instanceof KeystoneUpdateGroupOption) {
            groupOption = (KeystoneUpdateGroupOption) body;
        } else if (body instanceof String) {
            String strBody = (String) body;
            try {
                groupOption = new ObjectMapper().readValue(strBody, KeystoneUpdateGroupOption.class);
            } catch (JsonProcessingException e) {
                throw new IllegalArgumentException("String request body must be a valid JSON with the proper keys");
            }
        } else {
            throw new IllegalArgumentException(
                    "Exchange body is mandatory and should be a valid JSON string or KeystoneUpdateGroupOption object");
        }

         
        if (ObjectHelper.isEmpty(clientConfigurations.getGroupId())) {
            if (LOG.isErrorEnabled()) {
                LOG.error("No group id given");
            }
            throw new IllegalArgumentException("Group id is mandatory to update group");
        }

         
        KeystoneUpdateGroupRequestBody requestBody = new KeystoneUpdateGroupRequestBody()
                .withGroup(groupOption);
        KeystoneUpdateGroupRequest request = new KeystoneUpdateGroupRequest()
                .withBody(requestBody)
                .withGroupId(clientConfigurations.getGroupId());
        KeystoneUpdateGroupResponse response = iamClient.keystoneUpdateGroup(request);
        exchange.getMessage().setBody(gson.toJson(response.getGroup()));
    }

    public Optional<CamelClusterMember> getLeader() {
        if (leaderSelector == null || isStoppingOrStopped()) {
            return Optional.empty();
        }

        try {
            Participant participant = leaderSelector.getLeader();

            return ObjectHelper.equal(participant.getId(), localMember.getId())
                    ? Optional.of(localMember)
                    : Optional.of(new CuratorClusterMember(participant));
        } catch (KeeperException.NoNodeException e) {
            LOGGER.debug("Failed to get get master because node '{}' does not yet exist (error: '{}')",
                    getFullPath(),
                    e.getMessage());
            return Optional.empty();
        } catch (Exception e) {
            throw new RuntimeCamelException(e);
        }
    }

    public Map<String, String> getServiceMetadata() {
        HashMap<String, String> metadata = new HashMap<>();
        if (configuration.getQueueArn() != null) {
            metadata.put("queueArn", configuration.getQueueArn());
        }
        if (configuration.getTopicArn() != null) {
            metadata.put("topicArn", configuration.getTopicArn());
        }
        return metadata;
    }

    protected void configureParameters(Query query) {
        int maxResults = getEndpoint().getMaximumResults();
        if (maxResults > 0) {
            query.setMaxResults(maxResults);
        }
         
        if (parameters != null) {
            for (Map.Entry<String, Object> entry : parameters.entrySet()) {
                query.setParameter(entry.getKey(), entry.getValue());
            }
        }
    }

    public static Expression bodyOgnlExpression(final String ognl) {
        return new ExpressionAdapter() {
            private Language bean;

            @Override
            public Object evaluate(Exchange exchange) {
                Object body = exchange.getIn().getBody();
                if (body == null) {
                    return null;
                }
                Expression ognlExp = bean.createExpression(null, new Object[] { null, body, ognl });
                ognlExp.init(exchange.getContext());
                return ognlExp.evaluate(exchange, Object.class);
            }

            @Override
            public void init(CamelContext context) {
                bean = context.resolveLanguage("bean");
            }

            @Override
            public String toString() {
                return "bodyOgnl(" + ognl + ")";
            }
        };
    }

    private void processExecuteSyncReport(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {

        String reportId;
        final Boolean includeDetails = getParameter(INCLUDE_DETAILS, exchange, IGNORE_BODY, IS_OPTIONAL, Boolean.class);

         
        ReportMetadata reportMetadata = exchange.getIn().getBody(ReportMetadata.class);
        if (reportMetadata != null) {
            reportId = reportMetadata.getId();
            if (reportId == null) {
                reportId = getParameter(REPORT_ID, exchange, IGNORE_BODY, NOT_OPTIONAL);
            }
        } else {
            reportId = getParameter(REPORT_ID, exchange, USE_BODY, NOT_OPTIONAL);
            reportMetadata = getParameter(REPORT_METADATA, exchange, IGNORE_BODY, IS_OPTIONAL, ReportMetadata.class);
        }

        analyticsClient.executeSyncReport(reportId, includeDetails, reportMetadata, determineHeaders(exchange),
                new AnalyticsApiClient.ReportResultsResponseCallback() {
                    @Override
                    public void onResponse(
                            AbstractReportResultsBase reportResults, Map<String, String> headers, SalesforceException ex) {
                        processResponse(exchange, reportResults, headers, ex, callback);
                    }
                });
    }

    private void setupEndpointStrategies() {
        Map<String, EndpointStrategy> endpointStrategies
                = getContext().getRegistry().findByTypeWithName(EndpointStrategy.class);
        if (endpointStrategies != null && !endpointStrategies.isEmpty()) {
            for (Entry<String, EndpointStrategy> entry : endpointStrategies.entrySet()) {
                EndpointStrategy strategy = entry.getValue();
                LOG.info("Using custom EndpointStrategy with id: {} and implementation: {}", entry.getKey(), strategy);
                getContext().getCamelContextExtension().registerEndpointCallback(strategy);
            }
        }
    }

    protected String logStep(StartupStep step) {
        long delta = step.getDuration();
        String pad = StringHelper.padString(step.getLevel());
        String out = String.format("%s", pad + step.getType());
        String out2 = String.format("%6s ms", delta);
        String out3;
        if (step.getName() != null) {
            out3 = String.format("%s(%s)", step.getDescription(), step.getName());
        } else {
            out3 = step.getDescription();
        }
        return String.format("%s : %s - %s", out2, out, out3);
    }

    protected void initialize() {
         
         
        getOutFilter().add(JmsConstants.JMS_HEADER_XUSER_ID);
        getOutFilter().add("JMSXAppID");
        getOutFilter().add("JMSXDeliveryCount");
        getOutFilter().add("JMSXProducerTXID");
        getOutFilter().add("JMSXConsumerTXID");
        getOutFilter().add("JMSXRcvTimestamp");
        getOutFilter().add("JMSXRecvTimestamp");
        getOutFilter().add("JMSXState");
    }

    public void createJob(Job job, Map<String, List<String>> headers, JobResponseCallback callback) {
        final Request request = getRequest(HttpMethod.POST, jobUrl(null), headers);
        try {
            marshalRequest(job, request);
        } catch (SalesforceException e) {
            callback.onResponse(null, Collections.emptyMap(), e);
            return;
        }
        doHttpRequestWithJobResponse(callback, request);
    }

    protected LongHistogram getInstrument(String name, String description) {
        LongHistogram timer = timers.get(name);
        if (timer == null) {
            synchronized (lock) {
                timer = timers.get(name);
                if (timer == null) {
                    Meter meter = getEndpoint().getMeter();
                    LongHistogramBuilder builder = meter.histogramBuilder(name).ofLongs();
                    if (description != null) {
                        builder.setDescription(description);
                    }
                    builder.setUnit(getEndpoint().getUnit().name().toLowerCase());
                    timer = builder.build();
                    timers.put(name, timer);
                }
            }
        }
        return timer;
    }

    private String determineObjectName(Exchange exchange) {
        String key = getConfiguration().getObjectName();
        if (ObjectHelper.isEmpty(key)) {
            key = exchange.getIn().getHeader(GoogleCloudStorageConstants.OBJECT_NAME, String.class);
        }
        if (key == null) {
            throw new IllegalArgumentException("Google Cloud Storage object name header missing.");
        }
        return key;
    }

    public static JsonObject asJsonObject(TransformerModel model) {
        JsonObject obj = new JsonObject();
        baseToJson(model, obj);
        artifactToJson(model, obj);
        obj.put("from", model.getFrom());
        obj.put("to", model.getTo());
        obj.entrySet().removeIf(e -> e.getValue() == null);
        JsonObject wrapper = new JsonObject();
        wrapper.put("transformer", obj);
        return wrapper;
    }

    private static int getIndex(GenericDeclaration declaration, TypeVariable<?> variable) {
        Type[] typeParameters = declaration.getTypeParameters();
        for (int i = 0; i < typeParameters.length; i++) {
            if (typeParameters[i] instanceof TypeVariable) {
                TypeVariable<?> variableArgument = (TypeVariable<?>) typeParameters[i];
                if (variableArgument.getName().equals(variable.getName())) {
                    return i;
                }
            }
        }
        return -1;
    }

    protected void prepareDataFormatConfig(Map<String, Object> properties) {
        properties.put("keyUserid", definition.getKeyUserid());
        properties.put("signatureKeyUserid", definition.getSignatureKeyUserid());
        properties.put("password", definition.getPassword());
        properties.put("signaturePassword", definition.getSignaturePassword());
        properties.put("keyFileName", definition.getKeyFileName());
        properties.put("signatureKeyFileName", definition.getSignatureKeyFileName());
        properties.put("signatureKeyRing", definition.getSignatureKeyRing());
        properties.put("armored", definition.getArmored());
        properties.put("integrity", definition.getIntegrity());
        properties.put("provider", definition.getProvider());
        properties.put("algorithm", definition.getAlgorithm());
        properties.put("compressionAlgorithm", definition.getCompressionAlgorithm());
        properties.put("hashAlgorithm", definition.getHashAlgorithm());
        properties.put("signatureVerificationOption", definition.getSignatureVerificationOption());
    }

        public void onMode(String channel, IRCUser user, IRCModeParser modeParser) {
            if (configuration.isOnMode()) {
                Exchange exchange = createOnModeExchange(channel, user, modeParser);
                try {
                    getProcessor().process(exchange);
                } catch (Exception e) {
                    handleException(e);
                }
            }
        }

    public String extractCompletionReason(String chunk) throws JsonProcessingException {
        if (chunk == null || chunk.trim().isEmpty()) {
            return null;
        }
        JsonNode node = MAPPER.readTree(chunk);
        JsonNode type = node.get("type");

        if (type != null && "message_delta".equals(type.asText())) {
            JsonNode delta = node.get("delta");
            if (delta != null) {
                JsonNode stopReason = delta.get("stop_reason");
                return stopReason != null && !stopReason.isNull() ? stopReason.asText() : null;
            }
        }
        return null;
    }

    protected AbstractGitHubConsumer(GitHubEndpoint endpoint, Processor processor) throws Exception {
        super(endpoint, processor);
        this.endpoint = endpoint;

        Registry registry = endpoint.getCamelContext().getRegistry();
        Object service = registry.lookupByName(GitHubConstants.GITHUB_REPOSITORY_SERVICE);
        if (service != null) {
            LOG.debug("Using RepositoryService found in registry {}", service.getClass().getCanonicalName());
            repositoryService = (RepositoryService) service;
        } else {
            repositoryService = new RepositoryService();
        }

        initService(repositoryService);
        repository = repositoryService.getRepository(endpoint.getRepoOwner(), endpoint.getRepoName());
    }

    public Producer createProducer() throws Exception {
        if (isTransacted() && getExchangePattern().isOutCapable()) {
            throw new IllegalArgumentException("SjmsProducer cannot be both transacted=true and exchangePattern=InOut");
        }

        Producer answer = new SjmsProducer(this);
        if (isSynchronous()) {
            return new SynchronousDelegateProducer(answer);
        } else {
            return answer;
        }
    }

    public Integer doCall() throws Exception {
        List<Row> rows = new ArrayList<>();

        List<Long> pids = findPids(name);
        if (pids.isEmpty()) {
            return 0;
        } else if (pids.size() > 1) {
            printer().println("Name or pid " + name + " matches " + pids.size()
                              + " running Camel integrations. Specify a name or PID that matches exactly one.");
            return 0;
        }

        this.pid = pids.get(0);

        Path outputFile = prepareAction(Long.toString(pid), "source", root -> {
            root.put("filter", "*");
        });

        JsonObject jo = waitForOutputFile(outputFile);
        if (jo != null) {
            JsonArray arr = (JsonArray) jo.get("routes");
            for (int i = 0; i < arr.size(); i++) {
                JsonObject o = (JsonObject) arr.get(i);
                Row row = new Row();
                row.location = extractSourceName(o.getString("source"));
                 
                if (!rows.contains(row)) {
                    List<JsonObject> lines = o.getCollection("code");
                    if (lines != null) {
                        for (JsonObject line : lines) {
                            Code code = new Code();
                            code.line = line.getInteger("line");
                            code.code = line.getString("code");
                            row.code.add(code);
                        }
                    }
                    boolean add = true;
                    if (filter != null) {
                        String f = filter;
                        boolean negate = filter.startsWith("-");
                        if (negate) {
                            f = f.substring(1);
                        }
                         
                        if (!f.endsWith("*")) {
                            f += "*";
                        }
                        boolean match = PatternHelper.matchPattern(row.location, f);
                        if (negate) {
                            match = !match;
                        }
                        if (!match) {
                            add = false;
                        }
                    }
                    if (add) {
                        rows.add(row);
                    }
                }
            }
        } else {
            printer().println("Response from running Camel with PID " + pid + " not received within 5 seconds");
            return 1;
        }

         
        rows.sort(this::sortRow);

        if (!rows.isEmpty()) {
            printSource(rows);
        }

         
        try {
            Files.deleteIfExists(outputFile);
        } catch (IOException e) {
             
        }

        return 0;
    }

    protected static String jibMavenPluginVersion(Path settings, Properties prop) {
        String answer = null;
        if (prop != null) {
            answer = prop.getProperty(JIB_MAVEN_PLUGIN_VERSION);
        }
        if (answer == null) {
            try {
                List<String> lines = RuntimeUtil.loadPropertiesLines(settings);
                answer = lines.stream().filter(l -> l.startsWith(JIB_MAVEN_PLUGIN_VERSION + "="))
                        .map(s -> StringHelper.after(s, "=")).findFirst().orElse(null);
            } catch (Exception e) {
                 
            }
        }
        return answer != null ? answer : "3.4.5";
    }

    public V putIfAbsent(K key, V value) {
        if (key == null || value == null) {
            throw new NullPointerException();
        }
        try (OperationContext<K, V> context = new OperationContext<>(this, key)) {
            delegate.compute(
                    key,
                    (k, v) -> {
                        context.result = extractValue(v);
                        if (v != null) {
                            return v;
                        }
                        return addChange(context, x -> value);
                    });
            return context.result;
        }
    }

    public boolean process(final Exchange exchange, final AsyncCallback callback) {
         
        final Map<String, Object> properties = new HashMap<>(endpoint.getEndpointProperties());
        propertiesHelper.getExchangeProperties(exchange, properties);

         
        endpoint.interceptProperties(properties);
        interceptProperties(properties);

         
        properties.put(Olingo2Endpoint.RESPONSE_HANDLER_PROPERTY, new Olingo2ResponseHandler<Object>() {
            @Override
            public void onResponse(Object response, Map<String, String> responseHeaders) {
                if (resultIndex != null) {
                    response = resultIndex.filterResponse(response);
                }

                 
                 
                exchange.getOut().setBody(response);
                 
                exchange.getOut().setHeaders(exchange.getIn().getHeaders());

                 
                exchange.getOut().setHeader(Olingo2Constants.RESPONSE_HTTP_HEADERS, responseHeaders);

                interceptResult(response, exchange);

                callback.done(false);
            }

            @Override
            public void onException(Exception ex) {
                exchange.setException(ex);
                callback.done(false);
            }

            @Override
            public void onCanceled() {
                exchange.setException(new RuntimeCamelException("OData HTTP Request cancelled!"));
                callback.done(false);
            }
        });

         
        final ApiMethod method = findMethod(exchange, properties);
        if (method == null) {
             
            callback.done(true);
            return true;
        }

        if (LOG.isDebugEnabled()) {
            LOG.debug("Invoking operation {} with {}", method.getName(), properties.keySet());
        }

        try {
            doInvokeMethod(method, properties);
        } catch (Exception e) {
            exchange.setException(RuntimeCamelException.wrapRuntimeCamelException(e));
            callback.done(true);
            return true;
        }

        return false;
    }

    public void setDataObjectFormatIdentifierDocumentationReferences(
            List<String> dataObjectFormatIdentifierDocumentationReferences) {
        if (dataObjectFormatIdentifierDocumentationReferences == null) {
            throw new IllegalArgumentException("Parameter 'dataObjectFormatIdentifierDocumentationReferences' is null");
        }
        for (String ref : dataObjectFormatIdentifierDocumentationReferences) {
            if (ref == null || ref.isEmpty()) {
                throw new IllegalArgumentException(
                        "At least one reference of the identifier of the data object format is null or empty");
            }
        }
        this.dataObjectFormatIdentifierDocumentationReferences
                = new ArrayList<>(dataObjectFormatIdentifierDocumentationReferences);
    }

    public static boolean updateResource(BuildContext buildContext, Path out, String data) {
        try {
            if (FileUtil.updateFile(out, data)) {
                refresh(buildContext, out);
                return true;
            }
        } catch (IOException e) {
            throw new IOError(e);
        }
        return false;
    }

    protected void initialize() {
         
         
        getOutFilter().add("JMSXUserID");
        getOutFilter().add("JMSXAppID");
        getOutFilter().add("JMSXDeliveryCount");
        getOutFilter().add("JMSXProducerTXID");
        getOutFilter().add("JMSXConsumerTXID");
        getOutFilter().add("JMSXRcvTimestamp");
        getOutFilter().add("JMSXRecvTimestamp");
        getOutFilter().add("JMSXState");
    }

    public HttpServerInitializerFactory(NettyHttpConsumer nettyConsumer) {
        this.consumer = nettyConsumer;
        this.configuration = nettyConsumer.getConfiguration();
        try {
            this.sslContext = createSSLContext(consumer.getContext(), consumer.getConfiguration());
        } catch (Exception e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        }

        if (sslContext != null) {
            LOG.info("Created SslContext {}", sslContext);
        }
    }

    public void process(Exchange exchange) {
        var context = exchange.getContext();
        var msg = exchange.getMessage();

        logRequestHeaders(procName, msg);

         
         
        var oauth = findOAuth(context).orElseGet(() -> {
            var factory = OAuthFactory.lookupFactory(context);
            return factory.createOAuth();
        });

         
         
        var session = oauth.getOrCreateSession(exchange);

         
         
        if (session.getUserProfile().isPresent()) {
            var userProfile = session.removeUserProfile().orElseThrow();
            try {
                userProfile = authenticateExistingUserProfile(oauth, userProfile);
                session.putUserProfile(userProfile);
                return;
            } catch (OAuthException ex) {
                log.error("Failed to authenticate: {}", userProfile.subject(), ex);
            }
        }

         
         
        var postLoginUrl = getPostLoginUrl(msg);
        log.info("Register post login url: {}", postLoginUrl);
        session.putValue("OAuthPostLoginUrl", postLoginUrl);

        var redirectUri = getRequiredProperty(exchange.getContext(), CAMEL_OAUTH_REDIRECT_URI);
        var params = new OAuthCodeFlowParams().setRedirectUri(redirectUri);
        var authRequestUrl = oauth.buildCodeFlowAuthRequestUrl(params);

        sendRedirect(msg, authRequestUrl);
    }

        Object next(boolean first) {
            Object answer = image;
             
            if (scanner.hasNext()) {
                image = getNext(first);
            } else {
                image = null;
            }

            if (answer == null) {
                 
                answer = image;
            }
            return answer;
        }

    public boolean remove(final String key) {
        Boolean rc = transactionTemplate.execute(new TransactionCallback<Boolean>() {
            public Boolean doInTransaction(TransactionStatus status) {
                int updateCount = delete(key);
                if (updateCount == 0) {
                    return Boolean.FALSE;
                } else {
                    return Boolean.TRUE;
                }
            }
        });
        return rc.booleanValue();
    }

    private GoogleCalendarApiCollection() {
        final Map<String, String> aliases = new HashMap<>();
        final Map<GoogleCalendarApiName, ApiMethodHelper<? extends ApiMethod>> apiHelpers = new EnumMap<>(GoogleCalendarApiName.class);
        final Map<Class<? extends ApiMethod>, GoogleCalendarApiName> apiMethods = new HashMap<>();

        List<String> nullableArgs;

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(GoogleCalendarApiName.ACL, new ApiMethodHelper<>(CalendarAclApiMethod.class, aliases, nullableArgs));
        apiMethods.put(CalendarAclApiMethod.class, GoogleCalendarApiName.ACL);

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(GoogleCalendarApiName.LIST, new ApiMethodHelper<>(CalendarCalendarListApiMethod.class, aliases, nullableArgs));
        apiMethods.put(CalendarCalendarListApiMethod.class, GoogleCalendarApiName.LIST);

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(GoogleCalendarApiName.CALENDARS, new ApiMethodHelper<>(CalendarCalendarsApiMethod.class, aliases, nullableArgs));
        apiMethods.put(CalendarCalendarsApiMethod.class, GoogleCalendarApiName.CALENDARS);

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(GoogleCalendarApiName.CHANNELS, new ApiMethodHelper<>(CalendarChannelsApiMethod.class, aliases, nullableArgs));
        apiMethods.put(CalendarChannelsApiMethod.class, GoogleCalendarApiName.CHANNELS);

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(GoogleCalendarApiName.COLORS, new ApiMethodHelper<>(CalendarColorsApiMethod.class, aliases, nullableArgs));
        apiMethods.put(CalendarColorsApiMethod.class, GoogleCalendarApiName.COLORS);

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(GoogleCalendarApiName.FREEBUSY, new ApiMethodHelper<>(CalendarFreebusyApiMethod.class, aliases, nullableArgs));
        apiMethods.put(CalendarFreebusyApiMethod.class, GoogleCalendarApiName.FREEBUSY);

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(GoogleCalendarApiName.EVENTS, new ApiMethodHelper<>(CalendarEventsApiMethod.class, aliases, nullableArgs));
        apiMethods.put(CalendarEventsApiMethod.class, GoogleCalendarApiName.EVENTS);

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(GoogleCalendarApiName.SETTINGS, new ApiMethodHelper<>(CalendarSettingsApiMethod.class, aliases, nullableArgs));
        apiMethods.put(CalendarSettingsApiMethod.class, GoogleCalendarApiName.SETTINGS);

        setApiHelpers(apiHelpers);
        setApiMethods(apiMethods);
    }

    public Double toDouble(JsonNode node, Exchange exchange) throws Exception {
        if (node instanceof NumericNode) {
            NumericNode nn = (NumericNode) node;
            if (nn.isFloatingPointNumber()) {
                return nn.asDouble();
            }
        }
        String text = node.asText();
        return Double.valueOf(text);
    }

    private void configureAuthentication(
            ManagementHttpServer server, HttpManagementServerConfigurationProperties configuration) {
        if (configuration.getBasicPropertiesFile() != null) {
            BasicAuthenticationConfigurer auth = new BasicAuthenticationConfigurer();
            auth.configureAuthentication(server.getConfiguration().getAuthenticationConfig(), configuration);
        } else if (configuration.getJwtKeystoreType() != null) {
            ObjectHelper.notNull(configuration.getJwtKeystorePath(), "jwtKeyStorePath");
            ObjectHelper.notNull(configuration.getJwtKeystorePassword(), "jwtKeyStorePassword");
            JWTAuthenticationConfigurer auth = new JWTAuthenticationConfigurer();
            auth.configureAuthentication(server.getConfiguration().getAuthenticationConfig(), configuration);
        }
    }

    public Processor wrap(Route route, Processor processor) {
        JtaTransactionErrorHandler answer;
         
         
         
         
         
         
         
         

         
        RouteDefinition routeDefinition = (RouteDefinition) route.getRoute();
        ErrorHandlerFactory builder = routeDefinition.getErrorHandlerFactory();

         
        if (builder instanceof RefErrorHandlerDefinition) {
             
            RefErrorHandlerDefinition builderRef = (RefErrorHandlerDefinition) builder;
            String ref = builderRef.getRef();
             
             
             
            if (ErrorHandlerHelper.isErrorHandlerFactoryConfigured(ref)) {
                LOG.debug("Looking up ErrorHandlerBuilder with ref: {}", ref);
                builder = ErrorHandlerHelper.lookupErrorHandlerFactory(route, ref, true);
            }
        }

        JtaTransactionErrorHandlerDefinition txBuilder;
        if (builder != null && builder.supportTransacted()) {
            if (!(builder instanceof JtaTransactionErrorHandlerDefinition)) {
                throw new RuntimeCamelException(
                        "The given transactional error handler builder '" + builder
                                                + "' is not of type '" + JtaTransactionErrorHandlerDefinition.class.getName()
                                                + "' which is required in this environment!");
            }
            LOG.debug("The ErrorHandlerBuilder configured is a JtaTransactionErrorHandlerDefinition: {}", builder);
            txBuilder = (JtaTransactionErrorHandlerDefinition) builder.cloneBuilder();
        } else {
            LOG.debug(
                    "No or no transactional ErrorHandlerBuilder configured, will use default JtaTransactionErrorHandlerDefinition settings");
            txBuilder = new JtaTransactionErrorHandlerDefinition();
        }

        txBuilder.setTransactedPolicy(this);

         
        if (builder != null) {
            route.addErrorHandlerFactoryReference(builder, txBuilder);
        }

        answer = createTransactionErrorHandler(route, processor, txBuilder);

         
        route.setErrorHandlerFactory(txBuilder);

         
        return answer;
    }

    protected void doStop() throws Exception {
        super.doStop();

        LOG.debug("Stopping Kubernetes Nodes Consumer");
        if (executor != null) {
            KubernetesHelper.close(nodesWatcher, nodesWatcher::getWatch);

            if (getEndpoint() != null && getEndpoint().getCamelContext() != null) {
                getEndpoint().getCamelContext().getExecutorServiceManager().shutdownNow(executor);
            } else {
                executor.shutdownNow();
            }
        }
        executor = null;
    }

    public DaprOperationResponse handle(Exchange exchange) {
        StateOperation stateOperation = configurationOptionsProxy.getStateOperation(exchange);
        DaprClient client = endpoint.getClient();

        switch (stateOperation) {
            case save:
                return saveState(exchange, client);
            case saveBulk:
                return saveBulkState(exchange, client);
            case get:
                return getState(exchange, client);
            case getBulk:
                return getBulkState(exchange, client);
            case delete:
                return deleteState(exchange, client);
            case executeTransaction:
                return executeStateTransaction(exchange, client);
            default:
                throw new IllegalArgumentException("Unsupported state operation");
        }
    }

    public void close() {
        if (!closed) {
            try {
                ClearScrollRequest clearScrollRequest = new ClearScrollRequest.Builder()
                        .scrollId(List.of(scrollId))
                        .build();

                esClient.clearScroll(clearScrollRequest);
                closed = true;
                exchange.setProperty(OpensearchConstants.PROPERTY_SCROLL_OPENSEARCH_QUERY_COUNT, requestCount);
            } catch (IOException e) {
                throw new IllegalStateException(e);
            }
        }
    }

    private void addConfigurationClass(Class<? extends CamelConfiguration>... configuration) {
        StringJoiner existing = new StringJoiner(",");
        if (configurationClasses != null && !configurationClasses.isEmpty()) {
            existing.add(configurationClasses);
        }
        if (configuration != null) {
            for (Class<? extends CamelConfiguration> clazz : configuration) {
                existing.add(clazz.getName());
            }
        }
        setConfigurationClasses(existing.toString());
    }

    private Map<String, String> parseQueryParam(Exchange exchange) {
        Map<String, String> queryParams = new HashMap<>();

        if (exchange.getIn().getHeader(Exchange.HTTP_QUERY) != null) {
            String[] pairs = exchange.getIn().getHeader(Exchange.HTTP_QUERY).toString().split("&");
            for (String pair : pairs) {
                String[] keyValuePair = pair.split("=");

                queryParams.put(keyValuePair[0], keyValuePair[1]);
            }
        }

        return queryParams;
    }

    private ClientConfigurations initializeConfigurations(ImageRecognitionEndpoint endpoint) {
        ClientConfigurations clientConfigurations = new ClientConfigurations();

        clientConfigurations.setAccessKey(getAccessKey(endpoint));
        clientConfigurations.setSecretKey(getSecretKey(endpoint));
        clientConfigurations.setProjectId(getProjectId(endpoint));
        clientConfigurations.setEndpoint(getEndpoint(endpoint));

        clientConfigurations.setIgnoreSslVerification(endpoint.isIgnoreSslVerification());
        if (clientConfigurations.isIgnoreSslVerification()) {
            LOG.warn("SSL verification is ignored. This is unsafe in production environment");
        }
        if (!StringUtils.isEmpty(endpoint.getProxyHost())) {
            clientConfigurations.setProxyHost(endpoint.getProxyHost());
            clientConfigurations.setProxyPort(endpoint.getProxyPort());
            clientConfigurations.setProxyUser(endpoint.getProxyUser());
            clientConfigurations.setProxyPassword(endpoint.getProxyPassword());
        }
        return clientConfigurations;
    }

    private XPathFunction createHeaderFunction() {
        return new XPathFunction() {
            @SuppressWarnings("rawtypes")
            public Object evaluate(List list) throws XPathFunctionException {
                if (!list.isEmpty()) {
                    Object value = list.get(0);
                    if (value != null) {
                        String headerText = exchange.get().getContext().getTypeConverter().convertTo(String.class, value);
                        return exchange.get().getIn().getHeader(headerText);
                    }
                }
                return null;
            }
        };
    }

    private void runAsyncPull(Message message, DockerClient client, Exchange exchange) throws InterruptedException {
        try (PullImageCmd cmd = executePullImageRequest(client, message)) {

            PullImageResultCallback item = cmd.exec(new PullImageResultCallback() {
                @Override
                public void onNext(PullResponseItem item) {
                    super.onNext(item);

                    LOG.trace("pull image callback {}", item);

                }
            });

            setResponse(exchange, item);
        }
    }

    public <T extends ManagedProcessorMBean> T getManagedProcessor(String id, Class<T> type) {
         
        if (getManagementStrategy().getManagementAgent() == null) {
            return null;
        }

        Processor processor = camelContext.getProcessor(id);
        ProcessorDefinition<?> def
                = camelContext.getCamelContextExtension().getContextPlugin(Model.class).getProcessorDefinition(id);

         
        if (def != null) {
            try {
                ObjectName on = getManagementStrategy().getManagementObjectNameStrategy()
                        .getObjectNameForProcessor(camelContext, processor, def);
                return getManagementStrategy().getManagementAgent().newProxyClient(on, type);
            } catch (MalformedObjectNameException e) {
                throw RuntimeCamelException.wrapRuntimeCamelException(e);
            }
        }

        return null;
    }

    protected void autoConfigure(String artifactId) {
         
        InputStream is = getClass().getResourceAsStream("/auto-configure/" + artifactId + ".java");
        if (is != null) {
            try {
                 
                DependencyDownloader downloader = getCamelContext().hasService(DependencyDownloader.class);
                 
                downloader.downloadHiddenDependency("org.apache.camel", "camel-joor", camelContext.getVersion());
                 
                String script = IOHelper.loadText(is);
                Language lan = camelContext.resolveLanguage("java");
                Expression exp = lan.createExpression(script);
                Object out = exp.evaluate(new DefaultExchange(camelContext), Object.class);
                if (ObjectHelper.isNotEmpty(out)) {
                    LOG.info("{}", out);
                }
            } catch (Exception e) {
                throw RuntimeCamelException.wrapRuntimeException(e);
            } finally {
                IOHelper.close(is);
            }
        }
    }

    private void getUser(IamClient iamClient, Exchange exchange) throws InvalidPayloadException {
        executeOperation(
                exchange,
                GetUserRequest.class,
                iamClient::getUser,
                () -> {
                    String userName = getRequiredHeader(exchange, IAM2Constants.USERNAME, String.class, MISSING_USER_NAME);
                    return iamClient.getUser(GetUserRequest.builder().userName(userName).build());
                },
                "Get user",
                (GetUserResponse response, Message message) -> {
                    if (response.user() != null) {
                        message.setHeader(IAM2Constants.USER_ARN, response.user().arn());
                        message.setHeader(IAM2Constants.USER_ID, response.user().userId());
                    }
                });
    }

    public void onReplaceAsync(Message message) {
        final BasicCache<Object, Object> cache = getCache(message);
        final Object key = message.getHeader(InfinispanConstants.KEY, configuration::getKey);
        final Object value = message.getHeader(InfinispanConstants.VALUE, configuration::getValue);
        final Object oldValue = message.getHeader(InfinispanConstants.OLD_VALUE, configuration::getOldValue);
        final CompletableFuture<Object> resultWithNewValue;
        final CompletableFuture<Boolean> resultWithNewAndOldValue;

        if (hasLifespan(message)) {
            long lifespan = message.getHeader(InfinispanConstants.LIFESPAN_TIME, long.class);
            TimeUnit timeUnit = message.getHeader(InfinispanConstants.LIFESPAN_TIME_UNIT, TimeUnit.class);

            if (hasMaxIdleTime(message)) {
                long maxIdle = message.getHeader(InfinispanConstants.MAX_IDLE_TIME, long.class);
                TimeUnit maxIdleTimeUnit = message.getHeader(InfinispanConstants.MAX_IDLE_TIME_UNIT, TimeUnit.class);

                if (ObjectHelper.isEmpty(oldValue)) {
                    resultWithNewValue = cache.replaceAsync(key, value, lifespan, timeUnit, maxIdle, maxIdleTimeUnit);
                    setResult(message, resultWithNewValue);
                } else {
                    resultWithNewAndOldValue
                            = cache.replaceAsync(key, oldValue, value, lifespan, timeUnit, maxIdle, maxIdleTimeUnit);
                    setResult(message, resultWithNewAndOldValue);
                }
            } else {
                if (ObjectHelper.isEmpty(oldValue)) {
                    resultWithNewValue = cache.replaceAsync(key, value, lifespan, timeUnit);
                    setResult(message, resultWithNewValue);
                } else {
                    resultWithNewAndOldValue = cache.replaceAsync(key, oldValue, value, lifespan, timeUnit);
                    setResult(message, resultWithNewAndOldValue);
                }
            }
        } else {
            if (ObjectHelper.isEmpty(oldValue)) {
                resultWithNewValue = cache.replaceAsync(key, value);
                setResult(message, resultWithNewValue);
            } else {
                resultWithNewAndOldValue = cache.replaceAsync(key, oldValue, value);
                setResult(message, resultWithNewAndOldValue);
            }
        }

    }

    protected String resolvePropertyPlaceholders(String str) {
        try {
            if (getCamelContext() != null) {
                return getCamelContext().resolvePropertyPlaceholders(str);
            } else {
                return str;
            }
        } catch (Exception ex) {
            throw RuntimeCamelException.wrapRuntimeCamelException(ex);
        }
    }

    public void process(Exchange exchange) throws Exception {
        Object payload = exchange.getMessage().getBody();
        if (payload == null) {
            return;
        }

        ProtobufSchema answer = computeIfAbsent(exchange);

        if (answer != null) {
            exchange.setProperty(SchemaHelper.CONTENT_SCHEMA, answer);
            exchange.setProperty(SchemaHelper.CONTENT_SCHEMA_TYPE, SchemaType.PROTOBUF.type());
            exchange.setProperty(SchemaHelper.CONTENT_CLASS, SchemaHelper.resolveContentClass(exchange, this.contentClass));
        }
    }

    private void createRecord(Exchange exchange) throws Exception {
        final Message in = exchange.getIn();
        final String tableName = getTableName(in);
        final String apiVersion = getApiVersion(in);
        final Class<?> requestModel = getRequestModel(in, tableName);
        final Class<?> responseModel = getResponseModel(in, tableName);

        validateBody(in, requestModel);

        Response response = client.reset()
                .types(MediaType.APPLICATION_JSON_TYPE)
                .path("now")
                .path(apiVersion)
                .path("table")
                .path(tableName)
                .query(ServiceNowParams.SYSPARM_DISPLAY_VALUE, in)
                .query(ServiceNowParams.SYSPARM_EXCLUDE_REFERENCE_LINK, in)
                .query(ServiceNowParams.SYSPARM_FIELDS, in)
                .query(ServiceNowParams.SYSPARM_INPUT_DISPLAY_VALUE, in)
                .query(ServiceNowParams.SYSPARM_SUPPRESS_AUTO_SYS_FIELD, in)
                .query(ServiceNowParams.SYSPARM_VIEW, in)
                .query(responseModel)
                .invoke(HttpMethod.POST, in.getMandatoryBody());

        setBodyAndHeaders(exchange.getIn(), responseModel, response);
    }

    public String dumpStepStatsAsXml(boolean fullStats) throws Exception {
        StringBuilder sb = new StringBuilder();
        sb.append("<camelContextStat")
                .append(String.format(" id=\"%s\" state=\"%s\" uptime=\"%s\"", getCamelId(), getState(), getUptimeMillis()));
         
        String stat = dumpStatsAsXml(fullStats);
        sb.append(" exchangesInflight=\"").append(getInflightExchanges()).append("\"");
        sb.append(" ").append(stat, 7, stat.length() - 2).append(">\n");

        MBeanServer server = getContext().getManagementStrategy().getManagementAgent().getMBeanServer();
        if (server != null) {
             
            String prefix = getContext().getManagementStrategy().getManagementAgent().getIncludeHostName() ? "*/" : "";
            ObjectName query = ObjectName
                    .getInstance(jmxDomain + ":context=" + prefix + getContext().getManagementName() + ",type=routes,*");
            Set<ObjectName> routes = server.queryNames(query, null);

            List<ManagedProcessorMBean> steps = new ArrayList<>();
             
            query = ObjectName
                    .getInstance(jmxDomain + ":context=" + prefix + getContext().getManagementName() + ",type=steps,*");
            Set<ObjectName> names = server.queryNames(query, null);
            for (ObjectName on : names) {
                ManagedStepMBean step
                        = context.getManagementStrategy().getManagementAgent().newProxyClient(on, ManagedStepMBean.class);
                steps.add(step);
            }
            steps.sort(new OrderProcessorMBeans());

             
            sb.append("  <routeStats>\n");
            for (ObjectName on : routes) {
                ManagedRouteMBean route
                        = context.getManagementStrategy().getManagementAgent().newProxyClient(on, ManagedRouteMBean.class);
                sb.append("    <routeStat")
                        .append(String.format(" id=\"%s\" state=\"%s\" uptime=\"%s\"", route.getRouteId(), route.getState(),
                                route.getUptimeMillis()));
                if (route.getRouteGroup() != null) {
                    sb.append(String.format(" group=\"%s\"", route.getRouteGroup()));
                }
                if (route.getSourceLocation() != null) {
                    sb.append(String.format(" sourceLocation=\"%s\"", route.getSourceLocation()));
                }

                 
                stat = route.dumpStatsAsXml(fullStats);
                sb.append(" exchangesInflight=\"").append(route.getExchangesInflight()).append("\"");
                sb.append(" ").append(stat, 7, stat.length() - 2).append(">\n");

                 
                sb.append("      <stepStats>\n");
                for (ManagedProcessorMBean step : steps) {
                     
                    if (route.getRouteId().equals(step.getRouteId())) {
                        int line = step.getSourceLineNumber() != null ? step.getSourceLineNumber() : -1;
                        sb.append("        <stepStat")
                                .append(String.format(
                                        " id=\"%s\" index=\"%s\" state=\"%s\" disabled=\"%s\" sourceLineNumber=\"%s\"",
                                        step.getProcessorId(), step.getIndex(), step.getState(), step.getDisabled(), line));
                         
                        stat = step.dumpStatsAsXml(fullStats);
                        sb.append(" exchangesInflight=\"").append(step.getExchangesInflight()).append("\"");
                        sb.append(" ").append(stat, 7, stat.length()).append("\n");
                    }
                    sb.append("      </stepStats>\n");
                }
                sb.append("    </stepStat>\n");
            }
            sb.append("  </routeStats>\n");
        }

        sb.append("</camelContextStat>");
        return sb.toString();
    }

    private void attachVolumeToDroplet(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
        String volumeId = exchange.getIn().getHeader(DigitalOceanHeaders.ID, String.class);
        String volumeName = exchange.getIn().getHeader(DigitalOceanHeaders.VOLUME_NAME, String.class);
        Integer dropletId = exchange.getIn().getHeader(DigitalOceanHeaders.DROPLET_ID, Integer.class);
        String region = exchange.getIn().getHeader(DigitalOceanHeaders.REGION, String.class);

        if (ObjectHelper.isEmpty(dropletId)) {
            throw new IllegalArgumentException(DigitalOceanHeaders.DROPLET_ID + " must be specified");
        }

        if (ObjectHelper.isEmpty(region)) {
            throw new IllegalArgumentException(DigitalOceanHeaders.REGION + " must be specified");
        }

        Action action;

        if (ObjectHelper.isNotEmpty(volumeName)) {
            action = getEndpoint().getDigitalOceanClient().attachVolumeByName(dropletId, volumeName, region);
            LOG.trace("Attach Volume {} to Droplet {} [{}] ", volumeName, dropletId, action);
        } else if (ObjectHelper.isNotEmpty(volumeId)) {
            action = getEndpoint().getDigitalOceanClient().attachVolume(dropletId, volumeId, region);
            LOG.trace("Attach Volume {} to Droplet {} [{}] ", volumeId, dropletId, action);
        } else {
            throw new IllegalArgumentException(
                    DigitalOceanHeaders.ID + " or " + DigitalOceanHeaders.VOLUME_NAME + " must be specified");
        }

        exchange.getMessage().setBody(action);
    }

    public OperationResult<Boolean> getResult() {
        try {
            connection.delete(node, version);
            if (LOG.isDebugEnabled()) {
                if (LOG.isTraceEnabled()) {
                    LOG.trace(format("Set data of node '%s'", node));
                } else {
                    LOG.debug(format("Set data of node '%s'", node));
                }
            }
            return new OperationResult<>(true, null, true);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return new OperationResult<>(e);
        } catch (Exception e) {
            return new OperationResult<>(e);
        }
    }

    private void processAbortJob(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {
        JobInfo jobBody;
        String jobId;
        jobBody = exchange.getIn().getBody(JobInfo.class);
        if (jobBody != null) {
            jobId = jobBody.getId();
        } else {
            jobId = getParameter(JOB_ID, exchange, USE_BODY, NOT_OPTIONAL);
        }
        bulkClient.abortJob(jobId, determineHeaders(exchange), new BulkApiClient.JobInfoResponseCallback() {
            @Override
            public void onResponse(JobInfo jobInfo, Map<String, String> headers, SalesforceException ex) {
                processResponse(exchange, jobInfo, headers, ex, callback);
            }
        });
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
         
        if (!isRunAllowed()) {
            if (exchange.getException() == null) {
                exchange.setException(new RejectedExecutionException());
            }
             
            callback.done(true);
            return true;
        }

        try {
            if (!getEndpoint().isDisableReplyTo() && exchange.getPattern().isOutCapable()) {
                 
                return processInOut(exchange, callback);
            } else {
                 
                return processInOnly(exchange, callback);
            }
        } catch (Exception e) {
             
             
            exchange.setException(e);
            callback.done(true);
            return true;
        }
    }

                public void eventReceived(Action action, Pod resource) {
                    Exchange exchange = createExchange(false);
                    exchange.getIn().setBody(resource);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_ACTION, action);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_TIMESTAMP, System.currentTimeMillis());
                    try {
                        processor.process(exchange);
                    } catch (Exception e) {
                        getExceptionHandler().handleException("Error during processing", exchange, e);
                    } finally {
                        releaseExchange(exchange, false);
                    }
                }

    protected boolean processAsynchronously(
            final Exchange exchange, final AsyncCallback callback, ThrottlingState throttlingState) {
        try {
            if (LOG.isTraceEnabled()) {
                exchange.setProperty(PROPERTY_EXCHANGE_QUEUED_TIME, System.nanoTime());
            }
            exchange.setProperty(PROPERTY_EXCHANGE_STATE, State.ASYNC);
            asyncExecutor.submit(() -> process(exchange, callback));
            return false;
        } catch (final RejectedExecutionException e) {
            if (isCallerRunsWhenRejected()) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("AsyncExecutor is full, rejected exchange will run in the current thread, exchangeId: {}",
                            exchange.getExchangeId());
                }
                exchange.setProperty(PROPERTY_EXCHANGE_STATE, State.ASYNC_REJECTED);
                return process(exchange, callback);
            }
            throw e;
        }
    }

    public ApplicationPkcs7MimeEnvelopedDataEntity(MimeEntity entity2Encrypt,
                                                   CMSEnvelopedDataGenerator dataGenerator,
                                                   OutputEncryptor encryptor,
                                                   String encryptedContentTransferEncoding,
                                                   boolean isMainBody)
                                                                       throws HttpException {
        super(ContentType.create("application/pkcs7-mime", new BasicNameValuePair("smime-type", "enveloped-data"),
                new BasicNameValuePair("name", "smime.p7m")),
              encryptedContentTransferEncoding);
        addHeader(AS2Header.CONTENT_DISPOSITION, CONTENT_DISPOSITION);
        setMainBody(isMainBody);
        try {
            this.encryptedData = createEncryptedData(entity2Encrypt, dataGenerator, encryptor);
        } catch (Exception e) {
            throw new HttpException("Failed to create encrypted data");
        }
    }

    private boolean doCreateAndExecuteSqlStatement(Exchange exchange, String sql, Connection conn) throws Exception {

        Statement stmt = null;
        ResultSet rs = null;
        boolean shouldCloseResources = true;

        try {
            stmt = conn.createStatement();
            bindParameters(exchange, stmt);

            LOG.debug("Executing JDBC Statement: {}", sql);

            boolean shouldRetrieveGeneratedKeys
                    = exchange.getIn().getHeader(JdbcConstants.JDBC_RETRIEVE_GENERATED_KEYS, false, Boolean.class);

            boolean stmtExecutionResult;
            if (shouldRetrieveGeneratedKeys) {
                Object expectedGeneratedColumns = exchange.getIn().getHeader(JdbcConstants.JDBC_GENERATED_COLUMNS);
                if (expectedGeneratedColumns == null) {
                    stmtExecutionResult = stmt.execute(sql, Statement.RETURN_GENERATED_KEYS);
                } else if (expectedGeneratedColumns instanceof String[]) {
                    stmtExecutionResult = stmt.execute(sql, (String[]) expectedGeneratedColumns);
                } else if (expectedGeneratedColumns instanceof int[]) {
                    stmtExecutionResult = stmt.execute(sql, (int[]) expectedGeneratedColumns);
                } else {
                    throw new IllegalArgumentException(
                            "Header specifying expected returning columns isn't an instance of String[] or int[] but "
                                                       + expectedGeneratedColumns.getClass());
                }
            } else {
                stmtExecutionResult = stmt.execute(sql);
            }

            if (stmtExecutionResult) {
                rs = stmt.getResultSet();
                shouldCloseResources = setResultSet(exchange, conn, rs);
            } else {
                int updateCount = stmt.getUpdateCount();
                 
                exchange.getMessage().setHeader(JdbcConstants.JDBC_UPDATE_COUNT, updateCount);
            }

            if (shouldRetrieveGeneratedKeys) {
                setGeneratedKeys(exchange, conn, stmt.getGeneratedKeys());
            }
        } finally {
            if (shouldCloseResources) {
                closeQuietly(rs);
                closeQuietly(stmt);
            } else {
                final Statement finalStmt = stmt;
                final ResultSet finalRs = rs;
                exchange.getExchangeExtension().addOnCompletion(new SynchronizationAdapter() {
                    @Override
                    public void onDone(Exchange exchange) {
                        closeQuietly(finalRs);
                        closeQuietly(finalStmt);
                    }

                    @Override
                    public int getOrder() {
                         
                        return LOWEST + 100;
                    }
                });
            }
        }
        return shouldCloseResources;
    }

    private void processGetFailedResults(Exchange exchange, AsyncCallback callback)
            throws SalesforceException {
        String jobId = getParameter(JOB_ID, exchange, IGNORE_BODY, NOT_OPTIONAL);
        bulkClient.getFailedResults(jobId, determineHeaders(exchange),
                new StreamResponseCallback() {
                    @Override
                    public void onResponse(
                            InputStream inputStream, Map<String, String> headers, SalesforceException ex) {
                        processResponse(exchange, inputStream, headers, ex, callback);
                    }
                });
    }

            private void addTextIfNeeded() {
                if (textBuffer.length() > 0) {
                    final Element el = elementStack.isEmpty() ? null : elementStack.peek();
                    if (el != null) {
                        final Node textNode = doc.createTextNode(textBuffer.toString());
                        el.appendChild(textNode);
                        textBuffer.delete(0, textBuffer.length());
                    }
                }
            }

    public NettyConfiguration copy() {
        try {
            NettyConfiguration answer = (NettyConfiguration) clone();
             
            answer.setEncodersAsList(new ArrayList<>(getEncodersAsList()));
            answer.setDecodersAsList(new ArrayList<>(getDecodersAsList()));
            return answer;
        } catch (CloneNotSupportedException e) {
            throw new RuntimeCamelException(e);
        }
    }

    protected static MqttClientPersistence createMqttClientPersistence(PahoMqtt5Configuration configuration) {
        if (configuration.getPersistence() == PahoMqtt5Persistence.MEMORY) {
            return new MemoryPersistence();
        } else {
            if (configuration.getFilePersistenceDirectory() != null) {
                return new MqttDefaultFilePersistence(configuration.getFilePersistenceDirectory());
            } else {
                return new MqttDefaultFilePersistence();
            }
        }
    }

    protected String getHttpUrl(Exchange exchange, Endpoint endpoint) {
        Object url = exchange.getIn().getHeader(Exchange.HTTP_URL);
        if (url instanceof String) {
            return (String) url;
        } else {
            Object uri = exchange.getIn().getHeader(Exchange.HTTP_URI);
            if (uri instanceof String) {
                return (String) uri;
            } else {
                 
                int index = endpoint.getEndpointUri().lastIndexOf("http:");
                if (index != -1) {
                    return endpoint.getEndpointUri().substring(index);
                }
            }
        }
        return null;
    }

    private String getSecretFromSource(
            String key, String subkey, String defaultValue, String version)
            throws JsonProcessingException {

         
        secrets.add(key);

        String returnValue = null;
        try {
            SecretVersionName secretVersionName
                    = SecretVersionName.of(projectId, key, ObjectHelper.isNotEmpty(version) ? version : "latest");
            AccessSecretVersionResponse response = client.accessSecretVersion(secretVersionName);
            if (ObjectHelper.isNotEmpty(response)) {
                returnValue = response.getPayload().getData().toStringUtf8();
            }
            if (ObjectHelper.isNotEmpty(subkey) && ObjectHelper.isNotEmpty(returnValue)) {
                ObjectMapper mapper = new ObjectMapper();
                JsonNode actualObj = mapper.readTree(returnValue);
                JsonNode field = actualObj.get(subkey);
                if (ObjectHelper.isNotEmpty(field)) {
                    returnValue = field.textValue();
                } else {
                    returnValue = null;
                }
            }
            if (ObjectHelper.isEmpty(returnValue)) {
                returnValue = defaultValue;
            }
        } catch (ApiException ex) {
            if (ObjectHelper.isNotEmpty(defaultValue)) {
                returnValue = defaultValue;
            } else {
                throw ex;
            }
        }
        return returnValue;
    }

    private DaprOperationResponse getState(Exchange exchange, DaprClient client) {
        String stateStore = configurationOptionsProxy.getStateStore(exchange);
        String key = configurationOptionsProxy.getKey(exchange);
        Map<String, String> metadata = configurationOptionsProxy.getMetadata(exchange);
        StateOptions stateOptions = getStateOptions(exchange);

        GetStateRequest stateRequest = new GetStateRequest(stateStore, key);
        stateRequest.setMetadata(metadata);
        stateRequest.setStateOptions(stateOptions);

        State<byte[]> response = client.getState(stateRequest, TypeRef.get(byte[].class)).block();

        return DaprOperationResponse.create(response);
    }

    public Object filterResponse(Object response) {
        if (response instanceof ClientEntitySet) {
            response = filter((ClientEntitySet) response);
        } else if (response instanceof Iterable) {
            response = filter((Iterable<Object>) response);
        } else if (response.getClass().isArray()) {
            List<Object> result = new ArrayList<>();
            final int size = Array.getLength(response);
            for (int i = 0; i < size; i++) {
                result.add(Array.get(response, i));
            }
            response = filter(result);
        } else {
            response = filter(response);
        }

        return response;
    }

    protected Set<FieldInfo> fields(ClassInfo ci) {
        Set<FieldInfo> fields = new TreeSet<>(Comparator.comparing(FieldInfo::name));

        ClassInfo current = ci;
        while (current != null) {
            fields.addAll(current.fields());

            DotName superName = current.superName();
            if (superName == null) {
                break;
            }

            current = view.getClassByName(superName);
        }

        return fields;
    }

    private JAXBElement<Fault> createFaultFromException(final Throwable exception) {
        WebFault webFault = exception.getClass().getAnnotation(WebFault.class);
        if (webFault == null || webFault.targetNamespace() == null) {
            throw new RuntimeException(
                    "The exception " + exception.getClass().getName()
                                       + " needs to have an WebFault annotation with name and targetNamespace",
                    exception);
        }
        QName name = new QName(webFault.targetNamespace(), webFault.name());
        Object faultObject;
        try {
            Method method = exception.getClass().getMethod("getFaultInfo");
            faultObject = method.invoke(exception);
        } catch (Exception e) {
            throw new RuntimeCamelException("Exception while trying to get fault details", e);
        }
        Fault fault = new Fault();
        fault.setFaultcode(FAULT_CODE_SERVER);
        fault.setFaultstring(exception.getMessage());
        Detail detailEl = new ObjectFactory().createDetail();
        @SuppressWarnings("rawtypes")
        JAXBElement<?> faultDetailContent = new JAXBElement(name, faultObject.getClass(), faultObject);
        detailEl.getAny().add(faultDetailContent);
        fault.setDetail(detailEl);
        return new ObjectFactory().createFault(fault);
    }

    private void setupCustomServices() {
        ModelJAXBContextFactory modelJAXBContextFactory = getBeanForType(ModelJAXBContextFactory.class);
        if (modelJAXBContextFactory != null) {
            LOG.info("Using custom ModelJAXBContextFactory: {}", modelJAXBContextFactory);
            getContext().getCamelContextExtension().addContextPlugin(ModelJAXBContextFactory.class, modelJAXBContextFactory);
        }
        ClassResolver classResolver = getBeanForType(ClassResolver.class);
        if (classResolver != null) {
            LOG.info("Using custom ClassResolver: {}", classResolver);
            getContext().setClassResolver(classResolver);
        }
        FactoryFinderResolver factoryFinderResolver = getBeanForType(FactoryFinderResolver.class);
        if (factoryFinderResolver != null) {
            LOG.info("Using custom FactoryFinderResolver: {}", factoryFinderResolver);
            getContext().getCamelContextExtension().addContextPlugin(FactoryFinderResolver.class, factoryFinderResolver);
        }
        ExecutorServiceManager executorServiceStrategy = getBeanForType(ExecutorServiceManager.class);
        if (executorServiceStrategy != null) {
            LOG.info("Using custom ExecutorServiceStrategy: {}", executorServiceStrategy);
            getContext().setExecutorServiceManager(executorServiceStrategy);
        }
        ThreadPoolFactory threadPoolFactory = getBeanForType(ThreadPoolFactory.class);
        if (threadPoolFactory != null) {
            LOG.info("Using custom ThreadPoolFactory: {}", threadPoolFactory);
            getContext().getExecutorServiceManager().setThreadPoolFactory(threadPoolFactory);
        }
        ProcessorFactory processorFactory = getBeanForType(ProcessorFactory.class);
        if (processorFactory != null) {
            LOG.info("Using custom ProcessorFactory: {}", processorFactory);
            getContext().getCamelContextExtension().addContextPlugin(ProcessorFactory.class, processorFactory);
        }
        Debugger debugger = getBeanForType(Debugger.class);
        if (debugger != null) {
            LOG.info("Using custom Debugger: {}", debugger);
            getContext().setDebugger(debugger);
        }
        setupUuidGenerator();
        NodeIdFactory nodeIdFactory = getBeanForType(NodeIdFactory.class);
        if (nodeIdFactory != null) {
            LOG.info("Using custom NodeIdFactory: {}", nodeIdFactory);
            getContext().getCamelContextExtension().addContextPlugin(NodeIdFactory.class, nodeIdFactory);
        }
        StreamCachingStrategy streamCachingStrategy = getBeanForType(StreamCachingStrategy.class);
        if (streamCachingStrategy != null) {
            LOG.info("Using custom StreamCachingStrategy: {}", streamCachingStrategy);
            getContext().setStreamCachingStrategy(streamCachingStrategy);
        }
        MessageHistoryFactory messageHistoryFactory = getBeanForType(MessageHistoryFactory.class);
        if (messageHistoryFactory != null) {
            LOG.info("Using custom MessageHistoryFactory: {}", messageHistoryFactory);
            getContext().setMessageHistoryFactory(messageHistoryFactory);
        }
        ReactiveExecutor reactiveExecutor = getBeanForType(ReactiveExecutor.class);
        if (reactiveExecutor != null) {
             
            getContext().getCamelContextExtension().setReactiveExecutor(reactiveExecutor);
        }
    }

    protected int sortRow(Row o1, Row o2) {
         
        int answer = super.sortRow(o1, o2);
        if (answer == 0) {
            int negate = 1;
            if (sort.startsWith("-")) {
                negate = -1;
            }
             
            long m1 = o1.mean != null ? Long.parseLong(o1.mean) : 0;
            long m2 = o2.mean != null ? Long.parseLong(o2.mean) : 0;
            if (m1 < m2) {
                answer = negate;
            } else if (m1 > m2) {
                answer = -1 * negate;
            }
        }
        return answer;
    }

    private void processGetReportInstances(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {

        final String reportId = getParameter(REPORT_ID, exchange, USE_BODY, NOT_OPTIONAL);

        analyticsClient.getReportInstances(reportId, determineHeaders(exchange),
                new AnalyticsApiClient.ReportInstanceListResponseCallback() {
                    @Override
                    public void onResponse(
                            List<ReportInstance> reportInstances, Map<String, String> headers, SalesforceException ex) {
                        processResponse(exchange, reportInstances, headers, ex, callback);
                    }
                });
    }

private int jjMoveStringLiteralDfa4_0(long old0, long active0){
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_0(2, old0);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(3, active0);
      return 4;
   }
   switch(curChar)
   {
      case 84:
         return jjMoveStringLiteralDfa5_0(active0, 0x8L);
      default :
         break;
   }
   return jjStartNfa_0(3, active0);
}

    private CharsetDecoder charsetDecoder(IoSession session) {
        synchronized (session) {
            CharsetDecoder decoder = (CharsetDecoder) session.getAttribute(CHARSET_DECODER);
            if (decoder == null) {
                decoder = config.getCharset().newDecoder()
                        .onMalformedInput(config.getMalformedInputErrorAction())
                        .onUnmappableCharacter(config.getUnmappableCharacterErrorAction());
                session.setAttribute(CHARSET_DECODER, decoder);
            }
            return decoder;
        }
    }

    public boolean add(final Exchange exchange, final String messageId) {
        final EntityManager entityManager
                = getTargetEntityManager(exchange, entityManagerFactory, true, sharedEntityManager, true);
         
        final Boolean[] rc = new Boolean[1];
        transactionStrategy.executeInTransaction(() -> {
            if (isJoinTransaction()) {
                entityManager.joinTransaction();
            }

            try {
                List<?> list = query(entityManager, messageId);
                if (list.isEmpty()) {
                    MessageProcessed processed = new MessageProcessed();
                    processed.setProcessorName(processorName);
                    processed.setMessageId(messageId);
                    processed.setCreatedAt(new Date());
                    entityManager.persist(processed);
                    entityManager.flush();
                    entityManager.close();
                    rc[0] = Boolean.TRUE;
                } else {
                    rc[0] = Boolean.FALSE;
                }
            } catch (Exception ex) {
                String contextInfo = String.format(SOMETHING_WENT_WRONG, ex.getMessage());
                throw new PersistenceException(contextInfo, ex);
            } finally {
                try {
                    if (entityManager.isOpen()) {
                        entityManager.close();
                    }
                } catch (Exception e) {
                     
                }
            }
        });

        LOG.debug("add {} -> {}", messageId, rc[0]);
        return rc[0];
    }

    private void runAsyncWaitContainer(Exchange exchange, Message message, DockerClient client) throws InterruptedException {
        try (WaitContainerCmd cmd = executeWaitContainerRequest(client, message)) {
            WaitContainerResultCallback item = cmd.exec(new WaitContainerResultCallback() {
                @Override
                public void onNext(WaitResponse item) {
                    super.onNext(item);

                    LOG.trace("wait container callback {}", item);
                }

            });

            setResponse(exchange, item);
        }
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        try {
            OpenTelemetrySpanAdapter camelSpan = (OpenTelemetrySpanAdapter) ActiveSpanManager.getSpan(exchange);
            if (camelSpan != null) {
                String item = camelSpan.getContextPropagationItem(keyName);
                exchange.getMessage().setHeader(headerName, item);
            } else {
                LOG.warn("OpenTelemetry: Cannot find managed span for exchange: {}", exchange);
            }
        } catch (Exception e) {
            exchange.setException(e);
        } finally {
             
            callback.done(true);
        }

        return true;
    }

    public Predicate createPredicate(String expression, Object[] properties) {
        if (expression != null && isStaticResource(expression)) {
            expression = loadResource(expression);
        }

        String source = property(String.class, properties, 1, null);
        Expression input = ExpressionBuilder.singleInputExpression(source);
        if (getCamelContext() != null) {
            input.init(getCamelContext());
        }
        return createPredicate(input, expression, properties);
    }

    public void getReportInstances(
            String reportId, final Map<String, List<String>> headers, final ReportInstanceListResponseCallback callback) {

        final Request request = getRequest(HttpMethod.GET, reportInstancesUrl(reportId), headers);

        doHttpRequest(request, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                List<ReportInstance> reportInstances = null;
                if (response != null) {
                    try {
                        reportInstances = unmarshalResponse(response, request, TypeReferences.REPORT_INSTANCE_LIST_TYPE);
                    } catch (SalesforceException e) {
                        ex = e;
                    }
                }
                callback.onResponse(reportInstances, headers, ex);
            }
        });
    }

    public String extractCompletionReason(String chunk) throws JsonProcessingException {
        if (chunk == null || chunk.trim().isEmpty()) {
            return null;
        }
        JsonNode node = MAPPER.readTree(chunk);
        JsonNode outputs = node.get("outputs");
        if (outputs != null && outputs.isArray() && outputs.size() > 0) {
            JsonNode firstOutput = outputs.get(0);
            JsonNode stopReason = firstOutput.get("stop_reason");
            return stopReason != null && !stopReason.isNull() ? stopReason.asText() : null;
        }
        return null;
    }

    private boolean isBulkV2Operation(OperationName operationName) {
        switch (operationName) {
            case BULK2_CREATE_JOB:
            case BULK2_CREATE_BATCH:
            case BULK2_CLOSE_JOB:
            case BULK2_GET_JOB:
            case BULK2_ABORT_JOB:
            case BULK2_DELETE_JOB:
            case BULK2_GET_SUCCESSFUL_RESULTS:
            case BULK2_GET_FAILED_RESULTS:
            case BULK2_GET_UNPROCESSED_RECORDS:
            case BULK2_GET_ALL_JOBS:
            case BULK2_CREATE_QUERY_JOB:
            case BULK2_GET_QUERY_JOB:
            case BULK2_GET_QUERY_JOB_RESULTS:
            case BULK2_ABORT_QUERY_JOB:
            case BULK2_DELETE_QUERY_JOB:
            case BULK2_GET_ALL_QUERY_JOBS:
                return true;
            default:
                return false;
        }
    }

    public Message toCamelMessage(InboundStreamHttpRequest request, Exchange exchange, NettyHttpConfiguration configuration)
            throws Exception {
        LOG.trace("toCamelMessage: {}", request);

        NettyHttpMessage answer = new NettyHttpMessage(exchange.getContext(), null, null);
        answer.setExchange(exchange);
        if (configuration.isMapHeaders()) {
            populateCamelHeaders(request.getHttpRequest(), answer.getHeaders(), exchange, configuration);
        }

        answer.setBody(request.getInputStream());
        return answer;
    }

    private void deleteCollection(Exchange exchange) throws Exception {
        final Message in = exchange.getMessage();

        String collectionName;
        if (in.getHeader(WeaviateVectorDbHeaders.COLLECTION_NAME, String.class) != null) {
            collectionName = in.getHeader(WeaviateVectorDbHeaders.COLLECTION_NAME, String.class);
        } else {
            collectionName = getEndpoint().getCollection();
        }

        Result<Boolean> result = this.client.schema().classDeleter()
                .withClassName(collectionName)
                .run();

        populateResponse(result, exchange);
    }

    public String getMainJsonSchema() {
        String path = "META-INF/camel-main-configuration-metadata.json";
        InputStream is = null;
        if (classLoader != null) {
            is = classLoader.getResourceAsStream(path);
        }
        if (is == null) {
            ClassResolver resolver = camelContext.getClassResolver();
            is = resolver.loadResourceAsStream(path);
        }
        if (is != null) {
            try {
                return IOHelper.loadText(is);
            } catch (IOException e) {
                 
            } finally {
                IOHelper.close(is);
            }
        }
        return null;
    }

    public Processor createErrorHandler(Processor processor) throws Exception {
        String uri = parseString(definition.getDeadLetterUri());
        ObjectHelper.notNull(uri, "deadLetterUri", this);

         
        RedeliveryPolicy redeliveryPolicy = resolveRedeliveryPolicy(definition, camelContext);
        CamelLogger logger = resolveLogger(definition);

        Processor deadLetterProcessor = createDeadLetterChannelProcessor(uri);

        DeadLetterChannel answer = new DeadLetterChannel(
                camelContext, processor, logger,
                getProcessor(definition.getOnRedeliveryProcessor(), definition.getOnRedeliveryRef()),
                redeliveryPolicy, deadLetterProcessor, uri,
                parseBoolean(definition.getDeadLetterHandleNewException(), true),
                parseBoolean(definition.getUseOriginalMessage(), false),
                parseBoolean(definition.getUseOriginalBody(), false),
                resolveRetryWhilePolicy(definition, camelContext),
                getExecutorService(definition.getExecutorServiceBean(), definition.getExecutorServiceRef()),
                getProcessor(definition.getOnPrepareFailureProcessor(), definition.getOnPrepareFailureRef()),
                getProcessor(definition.getOnExceptionOccurredProcessor(), definition.getOnExceptionOccurredRef()));
         
        configure(answer);
        return answer;
    }

    protected void doStart() throws Exception {
        if (isServiceLocationEnabled()) {
             
            BeanIntrospection bi = PluginHelper.getBeanIntrospection(getCamelContext());
            DataSource ds = getDataSource();
             
            if (ds != null && ds.getClass().getName().endsWith("ClientProxy")) {
                DataSource actual = UnwrapHelper.unwrapClientProxy(ds);
                if (actual != null) {
                    ds = actual;
                }
            }
            serviceUrl = SqlServiceLocationHelper.getJDBCURLFromDataSource(bi, ds);

            serviceMetadata = new HashMap<>();
            String user = SqlServiceLocationHelper.getUsernameFromConnectionFactory(bi, ds);
            if (user != null) {
                serviceMetadata.put("username", user);
            }
        }
    }

    protected void mapElement(ParserContext ctx, BeanDefinitionBuilder bean, Element el, String name) {
        if ("properties".equals(name) || "headers".equals(name)) {
            Map<?, ?> map = ctx.getDelegate().parseMapElement(el, bean.getBeanDefinition());
            bean.addPropertyValue(name, map);
        } else if ("binding".equals(name)) {
            setFirstChildAsProperty(el, ctx, bean, "bindingConfig");
        } else if ("inInterceptors".equals(name) || "inFaultInterceptors".equals(name)
                || "outInterceptors".equals(name) || "outFaultInterceptors".equals(name)) {
            List<?> list = ctx.getDelegate().parseListElement(el, bean.getBeanDefinition());
            bean.addPropertyValue(name, list);
        } else if ("features".equals(name) || "providers".equals(name)
                || "schemaLocations".equals(name) || "modelBeans".equals(name)) {
            List<?> list = ctx.getDelegate().parseListElement(el, bean.getBeanDefinition());
            bean.addPropertyValue(name, list);
        } else if ("model".equals(name)) {
            List<UserResource> resources = ResourceUtils.getResourcesFromElement(el);
            bean.addPropertyValue("modelBeans", resources);
        } else {
            setFirstChildAsProperty(el, ctx, bean, name);
        }
    }

        public void calculateAndSetMaxRequestsPerPeriod(final Exchange exchange) throws Exception {
            lock.lock();
            try {
                Integer newThrottle
                        = TotalRequestsThrottler.this.getMaximumRequestsExpression().evaluate(exchange, Integer.class);

                if (newThrottle != null && newThrottle < 0) {
                    throw new IllegalStateException(
                            "The maximumRequestsPerPeriod must be a positive number, was: " + newThrottle);
                }

                if (newThrottle == null && throttleRate == 0) {
                    throw new RuntimeExchangeException(
                            "The maxRequestsPerPeriodExpression was evaluated as null: "
                                                       + TotalRequestsThrottler.this.getMaximumRequestsExpression(),
                            exchange);
                }

                if (newThrottle != null) {
                    if (newThrottle != throttleRate) {
                         
                        if (throttleRate > newThrottle) {
                            int delta = throttleRate - newThrottle;

                             
                            while (delta > 0) {
                                delayQueue.take();
                                delta--;
                                if (LOG.isTraceEnabled()) {
                                    LOG.trace("Permit discarded due to throttling rate decrease, triggered by ExchangeId: {}",
                                            exchange.getExchangeId());
                                }
                            }
                            if (LOG.isDebugEnabled()) {
                                LOG.debug("Throttle rate decreased from {} to {}, triggered by ExchangeId: {}", throttleRate,
                                        newThrottle, exchange.getExchangeId());
                            }

                             
                        } else if (newThrottle > throttleRate) {
                            int delta = newThrottle - throttleRate;
                            for (int i = 0; i < delta; i++) {
                                delayQueue.put(new ThrottlePermit(-1));
                            }
                            if (throttleRate == 0) {
                                if (LOG.isDebugEnabled()) {
                                    LOG.debug("Initial throttle rate set to {}, triggered by ExchangeId: {}", newThrottle,
                                            exchange.getExchangeId());
                                }
                            } else {
                                if (LOG.isDebugEnabled()) {
                                    LOG.debug("Throttle rate increase from {} to {}, triggered by ExchangeId: {}", throttleRate,
                                            newThrottle, exchange.getExchangeId());
                                }
                            }
                        }
                        throttleRate = newThrottle;
                    }
                }
            } finally {
                lock.unlock();
            }
        }

        public Destination createDestination(Session session, String destinationName, boolean topic) throws JMSException {
            QueueReplyManager.this.lock.lock();
            try {
                 
                if (destination == null) {
                    destination = delegate.createDestination(session, destinationName, topic);
                    setReplyTo(destination);
                }
            } finally {
                QueueReplyManager.this.lock.unlock();
            }
            return destination;
        }

    protected void doList(Exchange exchange) {
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        JobList jobList;

        if (ObjectHelper.isEmpty(namespace)) {
            jobList = getEndpoint().getKubernetesClient().batch().v1().jobs().inAnyNamespace().list();
        } else {
            jobList = getEndpoint().getKubernetesClient().batch().v1().jobs().inNamespace(namespace).list();
        }

        prepareOutboundMessage(exchange, jobList.getItems());
    }

    private void reconnect() throws InterruptedException, IOException, SmackException, XMPPException {
        lock.lock();
        try {
            if (!connection.isConnected()) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("Reconnecting to: {}", XmppEndpoint.getConnectionMessage(connection));
                }
                connection.connect();
            }
        } finally {
            lock.unlock();
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.ehcache.EhcacheProducer target = (org.apache.camel.component.ehcache.EhcacheProducer) obj;
        switch (key) {
        case "clear":
        case "CLEAR": target.onClear(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        case "put_if_absent":
        case "PUT_IF_ABSENT": target.onPutIfAbsent(exchange.getMessage()); return null;
        case "remove":
        case "REMOVE": target.onRemove(exchange.getMessage()); return null;
        case "remove_all":
        case "REMOVE_ALL": target.onRemoveAll(exchange.getMessage()); return null;
        case "replace":
        case "REPLACE": target.onReplace(exchange.getMessage()); return null;
        default: return null;
        }
    }

    protected void doRemove(Exchange exchange, String operation) throws GitAPIException {
        String fileName = null;
        if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(GitConstants.GIT_FILE_NAME))) {
            fileName = exchange.getIn().getHeader(GitConstants.GIT_FILE_NAME, String.class);
        } else {
            throw new IllegalArgumentException("File name must be specified to execute " + operation);
        }
        try {
            if (ObjectHelper.isNotEmpty(endpoint.getBranchName())) {
                git.checkout().setCreateBranch(false).setName(endpoint.getBranchName()).call();
            }
            git.rm().addFilepattern(fileName).call();
        } catch (GitAPIException e) {
            LOG.error("There was an error in Git {} operation", operation);
            throw e;
        }
    }

    public <T extends Enum<T>> T getEnum(final String key) throws ClassNotFoundException {
         
        T returnable;
        final String value;
        final String[] splitValues;
        final int numberOfSplitValues;
        final StringBuilder returnTypeName;
        final StringBuilder enumName;
        final Class<T> returnType;
         
        value = this.getStringOrDefault(key, "");
        if (value == null) {
            return null;
        }
         
        splitValues = value.split("\\.");
        numberOfSplitValues = splitValues.length;
        returnTypeName = new StringBuilder();
        enumName = new StringBuilder();
        for (int i = 0; i < numberOfSplitValues; i++) {
            if (i == (numberOfSplitValues - 1)) {
                 
                enumName.append(splitValues[i]);
            } else if (i == (numberOfSplitValues - 2)) {
                 
                returnTypeName.append(splitValues[i]);
            } else {
                 
                returnTypeName.append(splitValues[i]);
                returnTypeName.append(".");
            }
        }
         
        returnType = (Class<T>) Class.forName(returnTypeName.toString());
        returnable = Enum.valueOf(returnType, enumName.toString());
        return returnable;
    }

    protected void doStart() throws Exception {
        super.doStart();

        if (vertx == null) {
            if (vertxOptions != null) {
                vertx = Vertx.vertx(vertxOptions);
            } else {
                vertx = Vertx.vertx();
            }
            managedVertx = true;
        }
    }

    protected void decode(ChannelHandlerContext ctx, AddressedEnvelope<Object, InetSocketAddress> msg, List<Object> out)
            throws Exception {
        if (msg.content() instanceof ByteBuf) {
            delegateDecoder.decode(ctx, (ByteBuf) msg.content(), out);
            byte[] content = (byte[]) out.remove(out.size() - 1);
            AddressedEnvelope<Object, InetSocketAddress> addressedEnvelop
                    = new DefaultAddressedEnvelope<>(content, msg.recipient(), msg.sender());
            out.add(addressedEnvelop);
        } else {
            LOG.debug("Ignoring message content as it is not an io.netty.buffer.ByteBuf instance.");
        }
    }

    public Exchange receiveNoWait(Exchange exchange) {
        if (LOG.isTraceEnabled()) {
            LOG.trace("receiveNoWait polling file: {}", getConsumer().getEndpoint());
        }
        int polled = doReceive(exchange, 0);
        if (polled > 0) {
            return super.receive(0);
        } else {
            return null;
        }
    }

    public int getPort() {
        if (uri.getPort() == -1) {
            if ("cometds".equals(getProtocol())) {
                return 443;
            } else {
                return 80;
            }
        }
        return uri.getPort();
    }

    private static String detectMimeTypeFromExtension(String fileName) {
        String lowerName = fileName.toLowerCase();

         
        if (lowerName.endsWith(".png")) {
            return "image/png";
        } else if (lowerName.endsWith(".jpg") || lowerName.endsWith(".jpeg")) {
            return "image/jpeg";
        } else if (lowerName.endsWith(".gif")) {
            return "image/gif";
        } else if (lowerName.endsWith(".webp")) {
            return "image/webp";
        } else if (lowerName.endsWith(".bmp")) {
            return "image/bmp";
        } else if (lowerName.endsWith(".tiff") || lowerName.endsWith(".tif")) {
            return "image/tiff";
        } else if (lowerName.endsWith(".svg")) {
            return "image/svg+xml";
        }
         
        else if (lowerName.endsWith(".mp4")) {
            return "video/mp4";
        } else if (lowerName.endsWith(".webm")) {
            return "video/webm";
        } else if (lowerName.endsWith(".mov")) {
            return "video/quicktime";
        } else if (lowerName.endsWith(".mkv")) {
            return "video/x-matroska";
        } else if (lowerName.endsWith(".avi")) {
            return "video/x-msvideo";
        }
         
        else if (lowerName.endsWith(".wav")) {
            return "audio/wav";
        } else if (lowerName.endsWith(".mp3")) {
            return "audio/mpeg";
        } else if (lowerName.endsWith(".ogg")) {
            return "audio/ogg";
        } else if (lowerName.endsWith(".m4a")) {
            return "audio/mp4";
        } else if (lowerName.endsWith(".flac")) {
            return "audio/flac";
        }
         
        else if (lowerName.endsWith(".pdf")) {
            return "application/pdf";
        }
         
        else if (lowerName.endsWith(".txt")) {
            return "text/plain";
        } else if (lowerName.endsWith(".csv")) {
            return "text/csv";
        } else if (lowerName.endsWith(".html") || lowerName.endsWith(".htm")) {
            return "text/html";
        } else if (lowerName.endsWith(".md")) {
            return "text/markdown";
        } else if (lowerName.endsWith(".xml")) {
            return "text/xml";
        } else if (lowerName.endsWith(".json")) {
            return "application/json";
        }

        LOG.warn("Could not detect MIME type from file extension: {}. Please set the CamelLangChain4jAgentMediaType header.",
                fileName);
        throw new IllegalArgumentException(
                "Cannot determine MIME type for file: " + fileName
                                           + ". Please set the CamelLangChain4jAgentMediaType header.");
    }

    private <REQ, RES> void executeOperation(
            Exchange exchange,
            Class<REQ> requestClass,
            Function<REQ, RES> pojoExecutor,
            Supplier<RES> headerExecutor,
            String operationName,
            BiConsumer<RES, Message> responseProcessor)
            throws InvalidPayloadException {

        RES result;
        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (requestClass.isInstance(payload)) {
                try {
                    result = pojoExecutor.apply(requestClass.cast(payload));
                } catch (AwsServiceException ase) {
                    LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                    throw ase;
                }
            } else {
                throw new IllegalArgumentException(
                        String.format("Expected body of type %s but was %s",
                                requestClass.getName(),
                                payload != null ? payload.getClass().getName() : "null"));
            }
        } else {
            try {
                result = headerExecutor.get();
            } catch (AwsServiceException ase) {
                LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                throw ase;
            }
        }
        Message message = getMessageForResponse(exchange);
        message.setBody(result);
        if (responseProcessor != null) {
            responseProcessor.accept(result, message);
        }
    }

    public static URL resolveMandatoryResourceAsUrl(CamelContext camelContext, String uri)
            throws FileNotFoundException, MalformedURLException {
        URL url = resolveResourceAsUrl(camelContext, uri);
        if (url == null) {
            String resolvedName = resolveUriPath(uri);
            throw new FileNotFoundException("Cannot find resource: " + resolvedName + " in classpath for URI: " + uri);
        } else {
            return url;
        }
    }

    private boolean accept(String name) {
        if (stubPattern == null) {
            return true;
        }

        boolean stubbed = false;
        for (String n : stubPattern.split(",")) {
            if (n.startsWith("dataformat:")) {
                stubbed |= PatternHelper.matchPattern(name, n.substring(11));
            }
        }
        return !stubbed;
    }

    private void doInsert(Exchange exchange, String tableName) throws KuduException {
        LOG.trace("Insert on table {}", tableName);
        KuduClient connection = endpoint.getKuduClient();
        KuduTable table = connection.openTable(tableName);

        Insert insert = table.newInsert();
        PartialRow row = insert.getRow();

        Map<?, ?> rows = exchange.getIn().getBody(Map.class);
        for (Map.Entry<?, ?> entry : rows.entrySet()) {
            final String colName = entry.getKey().toString();
            final Object value = entry.getValue();
             
             
            if (table.getSchema().getColumn(colName) != null) {
                row.addObject(colName, value);
            }
        }

        connection.newSession().apply(insert);
    }

    private PullImageCmd executePullImageRequest(DockerClient client, Message message) {

        LOG.debug("Executing Docker Pull Image Request");

        String repository = DockerHelper.getProperty(DockerConstants.DOCKER_REPOSITORY, configuration, message, String.class);

        ObjectHelper.notNull(repository, "Repository must be specified");

        PullImageCmd pullImageCmd = client.pullImageCmd(repository);

        String registry = DockerHelper.getProperty(DockerConstants.DOCKER_REGISTRY, configuration, message, String.class);
        if (registry != null) {
            pullImageCmd.withRegistry(registry);
        }

        String tag = DockerHelper.getProperty(DockerConstants.DOCKER_TAG, configuration, message, String.class);
        if (tag != null) {
            pullImageCmd.withTag(tag);
        }

        AuthConfig authConfig = client.authConfig();

        if (authConfig != null) {
            pullImageCmd.withAuthConfig(authConfig);
        }

        return pullImageCmd;

    }

    public void transform(Message message, DataType fromType, DataType toType) {
        final Map<String, Object> headers = message.getHeaders();

        CloudEvent cloudEvent = CloudEvents.v1_0;
        headers.putIfAbsent(CloudEvents.CAMEL_CLOUD_EVENT_ID, message.getExchange().getExchangeId());
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_VERSION, cloudEvent.version());
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_TYPE, "org.apache.camel.event.azure.storage.blob.getBlob");

        if (message.getHeaders().containsKey(BlobConstants.E_TAG)) {
            headers.put(CloudEvents.CAMEL_CLOUD_EVENT_SOURCE,
                    "azure.storage.blob." + message.getHeader(BlobConstants.E_TAG, String.class));
        }

        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_SUBJECT, message.getHeader(BlobConstants.BLOB_NAME, String.class));
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_TIME, cloudEvent.getEventTime(message.getExchange()));
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_CONTENT_TYPE, CloudEvents.APPLICATION_OCTET_STREAM_MIME_TYPE);
    }

    private String findEncryptionMethod(Element element) {
        Node child = element.getFirstChild();
        while (child != null) {
            if (child.getNodeType() == Node.ELEMENT_NODE) {
                Element childElement = (Element) child;
                if (EncryptionConstants._TAG_ENCRYPTIONMETHOD.equals(childElement.getLocalName())
                        && EncryptionConstants.EncryptionSpecNS.equals(childElement.getNamespaceURI())) {
                    return childElement.getAttributeNS(null, EncryptionConstants._ATT_ALGORITHM);
                }
            }
            child = child.getNextSibling();
        }

        return null;
    }

    private void createZipEntries(ZipArchiveOutputStream zos, String filepath, Long fileLength) throws IOException {
        Iterator<Path> elements = Paths.get(filepath).iterator();
        StringBuilder sb = new StringBuilder(256);

        while (elements.hasNext()) {
            Path path = elements.next();
            String element = path.toString();
            Long length = fileLength;

             
             
            if (elements.hasNext()) {
                element += "/";
                length = 0L;
            }

             
            ZipArchiveEntry entry = new ZipArchiveEntry(sb + element);
            entry.setSize(length);
            zos.putArchiveEntry(entry);

            sb.append(element);
        }
    }

    public void unregister(ObjectName name) throws JMException {
        if (isRegistered(name)) {
            ObjectName on = mbeansRegistered.remove(name);
            server.unregisterMBean(on);
            LOG.debug("Unregistered MBean with ObjectName: {}", name);
        } else {
            mbeansRegistered.remove(name);
        }
    }

    public void releaseExclusiveReadLockOnRollback(
            GenericFileOperations<File> operations, GenericFile<File> file, Exchange exchange)
            throws Exception {
        String key = asKey(exchange, file);
        Runnable r = () -> {
            if (removeOnRollback) {
                idempotentRepository.remove(exchange, key);
            } else {
                 
                idempotentRepository.confirm(exchange, key);
            }
        };

        delayOrScheduleLockRelease(r);
    }

    public Producer createProducer(
            CamelContext camelContext, String host,
            String verb, String basePath, String uriTemplate, String queryParameters,
            String consumes, String produces, RestConfiguration configuration, Map<String, Object> parameters)
            throws Exception {

         
        basePath = FileUtil.stripLeadingSeparator(basePath);
        uriTemplate = FileUtil.stripLeadingSeparator(uriTemplate);

         
        String url = host;
        if (!ObjectHelper.isEmpty(basePath)) {
            url += "/" + basePath;
        }
        if (!ObjectHelper.isEmpty(uriTemplate)) {
            url += "/" + uriTemplate;
        }

        RestConfiguration config = configuration;
        if (config == null) {
            config = CamelContextHelper.getRestConfiguration(getCamelContext(), null, "http");
        }

        Map<String, Object> map = new HashMap<>();
         
        if (config.getProducerComponent() == null || config.getProducerComponent().equals("http")) {
             
            map.put("httpMethod", verb);
            if (config.getEndpointProperties() != null && !config.getEndpointProperties().isEmpty()) {
                map.putAll(config.getEndpointProperties());
            }
        }

        url = HttpUtil.recreateUrl(map, url);

        parameters = parameters != null ? new HashMap<>(parameters) : new HashMap<>();

         
         
         
        RestProducerFactoryHelper.setupComponentFor(url, camelContext, (Map<String, Object>) parameters.remove("component"));

        HttpEndpoint endpoint = (HttpEndpoint) camelContext.getEndpoint(url, parameters);

        String path = uriTemplate != null ? uriTemplate : basePath;

        HeaderFilterStrategy headerFilterStrategy
                = resolveAndRemoveReferenceParameter(parameters, "headerFilterStrategy", HeaderFilterStrategy.class);
        if (headerFilterStrategy != null) {
            endpoint.setHeaderFilterStrategy(headerFilterStrategy);
        } else {
            endpoint.setHeaderFilterStrategy(new HttpRestHeaderFilterStrategy(path, queryParameters));
        }
         
        ServiceHelper.startService(endpoint);

        return endpoint.createProducer();
    }

    public PathHandler removePrefixPath(final String path) {
        lock.lock();
        try {
            super.removePrefixPath(path);
            handlers.remove(path);
            handlerString = null;
            return this;
        } finally {
            lock.unlock();
        }
    }

    private void add(Exchange exchange) throws Exception {
        final Message in = exchange.getMessage();

        String collectionName = getCollectionName(in);
        Collection collection = this.client.getCollection(collectionName, embeddingFunction);

        List<String> ids = in.getHeader(ChromaHeaders.IDS, List.class);
        List<Embedding> embeddings = getEmbeddings(in);
        List<Map<String, String>> metadatas = in.getHeader(ChromaHeaders.METADATAS, List.class);
        List<String> documents = in.getBody(List.class);

        collection.add(embeddings, metadatas, documents, ids);
        in.setHeader(ChromaHeaders.OPERATION_STATUS, "SUCCESS");
    }

    protected String getIdAndNoteDescription(Row r) {
        String id = getId(r);
        if (description && r.description != null) {
            if (id != null) {
                id = id + "\n  " + Strings.wrapWords(r.description, " ", "\n  ", 55, true);
            } else {
                id = r.description;
            }
        }
        if (note && r.note != null) {
            if (id != null) {
                id = id + "\n  " + Strings.wrapWords(r.note, " ", "\n  ", 55, true);
            } else {
                id = r.note;
            }
        }
        return id;
    }

    public int forceDiscardingOfGroup(String key) {
         
        int total = 0;

        lock.lock();
        try {
            Exchange exchange = aggregationRepository.get(camelContext, key);
            if (exchange != null) {
                total = 1;
                LOG.trace("Force discarded triggered for correlation key: {}", key);
                 
                onCompletion(key, exchange, exchange, false, true);
            }
        } finally {
            lock.unlock();
        }
        LOG.trace("Completed force discarded of group {}", key);

        if (total > 0) {
            LOG.debug("Forcing discarding of group {} with {} exchanges", key, total);
        }
        return total;
    }

    private void doCreateOrUpdateSecret(Exchange exchange, String operationName, Function<Resource<Secret>, Secret> operation) {
        String namespaceName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        Secret secretToCreate = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_SECRET, Secret.class);
        HashMap<String, String> secretAnnotations
                = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_SECRETS_ANNOTATIONS, HashMap.class);
        if (ObjectHelper.isEmpty(namespaceName)) {
            LOG.error("{} a specific secret require specify a namespace name", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific secret require specify a namespace name", operationName));
        }
        if (ObjectHelper.isEmpty(secretToCreate)) {
            LOG.error("{} a specific secret require specify a secret bean", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific secret require specify a secret bean", operationName));
        }
        if (ObjectHelper.isNotEmpty(secretAnnotations)) {
            secretToCreate.getMetadata().setAnnotations(secretAnnotations);
        }
        Secret secret
                = operation.apply(
                        getEndpoint().getKubernetesClient().secrets().inNamespace(namespaceName).resource(secretToCreate));

        prepareOutboundMessage(exchange, secret);
    }

    public void deregister(ServiceDefinition definition) {
        if (definition.getId() == null) {
            throw new IllegalArgumentException("Service ID must be defined (definition=" + definition + ")");
        }
        if (definition.getName() == null) {
            throw new IllegalArgumentException("Service Name must be defined (definition=" + definition + ")");
        }

        try {
            for (ServiceInstance<MetaData> serviceInstance : serviceDiscovery.queryForInstances(definition.getName())) {
                if (Objects.equals(serviceInstance.getId(), definition.getId())) {
                    serviceDiscovery.unregisterService(serviceInstance);

                     
                    serviceList.remove(serviceInstance.getId());
                }
            }
        } catch (Exception e) {
            LOGGER.warn("{}", e.getMessage(), e);
        }
    }

    protected boolean matchSecret(String name) {
        Set<String> set = new HashSet<>();
        if (secrets != null) {
            Collections.addAll(set, secrets.split(","));
        }
        if (propertiesFunction != null) {
            set.addAll(propertiesFunction.getSecrets());
        }

        for (String part : set) {
            boolean result = name.contains(part) || PatternHelper.matchPattern(name, part);
            LOG.trace("Matching secret id: {}={} -> {}", name, part, result);
            if (result) {
                return true;
            }
        }

        return false;
    }

        protected boolean setPropertyOnComponent(
                Component component,
                String name,
                Object value) {
            switch (name) {
            case "apexMethod": getOrCreateConfiguration((SalesforceComponent) component).setApexMethod((java.lang.String) value); return true;
            case "apexQueryParams": getOrCreateConfiguration((SalesforceComponent) component).setApexQueryParams((java.util.Map) value); return true;
            case "apiVersion": getOrCreateConfiguration((SalesforceComponent) component).setApiVersion((java.lang.String) value); return true;
            case "backoffIncrement": getOrCreateConfiguration((SalesforceComponent) component).setBackoffIncrement((long) value); return true;
            case "batchId": getOrCreateConfiguration((SalesforceComponent) component).setBatchId((java.lang.String) value); return true;
            case "contentType": getOrCreateConfiguration((SalesforceComponent) component).setContentType((org.apache.camel.component.salesforce.api.dto.bulk.ContentType) value); return true;
            case "defaultReplayId": getOrCreateConfiguration((SalesforceComponent) component).setDefaultReplayId((java.lang.Long) value); return true;
            case "fallBackReplayId": getOrCreateConfiguration((SalesforceComponent) component).setFallBackReplayId((java.lang.Long) value); return true;
            case "format": getOrCreateConfiguration((SalesforceComponent) component).setFormat((org.apache.camel.component.salesforce.internal.PayloadFormat) value); return true;
            case "httpClient": getOrCreateConfiguration((SalesforceComponent) component).setHttpClient((org.apache.camel.component.salesforce.SalesforceHttpClient) value); return true;
            case "httpClientConnectionTimeout": ((SalesforceComponent) component).setHttpClientConnectionTimeout((long) value); return true;
            case "httpClientIdleTimeout": ((SalesforceComponent) component).setHttpClientIdleTimeout((long) value); return true;
            case "httpMaxContentLength": ((SalesforceComponent) component).setHttpMaxContentLength((java.lang.Integer) value); return true;
            case "httpRequestBufferSize": ((SalesforceComponent) component).setHttpRequestBufferSize((java.lang.Integer) value); return true;
            case "httpRequestTimeout": ((SalesforceComponent) component).setHttpRequestTimeout((long) value); return true;
            case "includeDetails": getOrCreateConfiguration((SalesforceComponent) component).setIncludeDetails((java.lang.Boolean) value); return true;
            case "initialReplayIdMap": getOrCreateConfiguration((SalesforceComponent) component).setInitialReplayIdMap((java.util.Map) value); return true;
            case "instanceId": getOrCreateConfiguration((SalesforceComponent) component).setInstanceId((java.lang.String) value); return true;
            case "jobId": getOrCreateConfiguration((SalesforceComponent) component).setJobId((java.lang.String) value); return true;
            case "limit": getOrCreateConfiguration((SalesforceComponent) component).setLimit((java.lang.Integer) value); return true;
            case "locator": getOrCreateConfiguration((SalesforceComponent) component).setLocator((java.lang.String) value); return true;
            case "maxBackoff": getOrCreateConfiguration((SalesforceComponent) component).setMaxBackoff((long) value); return true;
            case "maxRecords": getOrCreateConfiguration((SalesforceComponent) component).setMaxRecords((java.lang.Integer) value); return true;
            case "notFoundBehaviour": getOrCreateConfiguration((SalesforceComponent) component).setNotFoundBehaviour((org.apache.camel.component.salesforce.NotFoundBehaviour) value); return true;
            case "notifyForFields": getOrCreateConfiguration((SalesforceComponent) component).setNotifyForFields((org.apache.camel.component.salesforce.internal.dto.NotifyForFieldsEnum) value); return true;
            case "notifyForOperationCreate": getOrCreateConfiguration((SalesforceComponent) component).setNotifyForOperationCreate((java.lang.Boolean) value); return true;
            case "notifyForOperationDelete": getOrCreateConfiguration((SalesforceComponent) component).setNotifyForOperationDelete((java.lang.Boolean) value); return true;
            case "notifyForOperations": getOrCreateConfiguration((SalesforceComponent) component).setNotifyForOperations((org.apache.camel.component.salesforce.internal.dto.NotifyForOperationsEnum) value); return true;
            case "notifyForOperationUndelete": getOrCreateConfiguration((SalesforceComponent) component).setNotifyForOperationUndelete((java.lang.Boolean) value); return true;
            case "notifyForOperationUpdate": getOrCreateConfiguration((SalesforceComponent) component).setNotifyForOperationUpdate((java.lang.Boolean) value); return true;
            case "objectMapper": getOrCreateConfiguration((SalesforceComponent) component).setObjectMapper((com.fasterxml.jackson.databind.ObjectMapper) value); return true;
            case "packages": ((SalesforceComponent) component).setPackages((java.lang.String) value); return true;
            case "pkChunking": getOrCreateConfiguration((SalesforceComponent) component).setPkChunking((java.lang.Boolean) value); return true;
            case "pkChunkingChunkSize": getOrCreateConfiguration((SalesforceComponent) component).setPkChunkingChunkSize((java.lang.Integer) value); return true;
            case "pkChunkingParent": getOrCreateConfiguration((SalesforceComponent) component).setPkChunkingParent((java.lang.String) value); return true;
            case "pkChunkingStartRow": getOrCreateConfiguration((SalesforceComponent) component).setPkChunkingStartRow((java.lang.String) value); return true;
            case "queryLocator": getOrCreateConfiguration((SalesforceComponent) component).setQueryLocator((java.lang.String) value); return true;
            case "rawPayload": getOrCreateConfiguration((SalesforceComponent) component).setRawPayload((boolean) value); return true;
            case "reportId": getOrCreateConfiguration((SalesforceComponent) component).setReportId((java.lang.String) value); return true;
            case "reportMetadata": getOrCreateConfiguration((SalesforceComponent) component).setReportMetadata((org.apache.camel.component.salesforce.api.dto.analytics.reports.ReportMetadata) value); return true;
            case "resultId": getOrCreateConfiguration((SalesforceComponent) component).setResultId((java.lang.String) value); return true;
            case "sObjectBlobFieldName": getOrCreateConfiguration((SalesforceComponent) component).setSObjectBlobFieldName((java.lang.String) value); return true;
            case "sObjectClass": getOrCreateConfiguration((SalesforceComponent) component).setSObjectClass((java.lang.String) value); return true;
            case "sObjectFields": getOrCreateConfiguration((SalesforceComponent) component).setSObjectFields((java.lang.String) value); return true;
            case "sObjectId": getOrCreateConfiguration((SalesforceComponent) component).setSObjectId((java.lang.String) value); return true;
            case "sObjectIdName": getOrCreateConfiguration((SalesforceComponent) component).setSObjectIdName((java.lang.String) value); return true;
            case "sObjectIdValue": getOrCreateConfiguration((SalesforceComponent) component).setSObjectIdValue((java.lang.String) value); return true;
            case "sObjectName": getOrCreateConfiguration((SalesforceComponent) component).setSObjectName((java.lang.String) value); return true;
            case "sObjectQuery": getOrCreateConfiguration((SalesforceComponent) component).setSObjectQuery((java.lang.String) value); return true;
            case "sObjectSearch": getOrCreateConfiguration((SalesforceComponent) component).setSObjectSearch((java.lang.String) value); return true;
            case "streamQueryResult": getOrCreateConfiguration((SalesforceComponent) component).setStreamQueryResult((java.lang.Boolean) value); return true;
            case "updateTopic": getOrCreateConfiguration((SalesforceComponent) component).setUpdateTopic((boolean) value); return true;
            case "config": ((SalesforceComponent) component).setConfig((org.apache.camel.component.salesforce.SalesforceEndpointConfig) value); return true;
            case "httpClientProperties": ((SalesforceComponent) component).setHttpClientProperties((java.util.Map) value); return true;
            case "longPollingTransportProperties": ((SalesforceComponent) component).setLongPollingTransportProperties((java.util.Map) value); return true;
            case "workerPoolMaxSize": ((SalesforceComponent) component).setWorkerPoolMaxSize((int) value); return true;
            case "workerPoolSize": ((SalesforceComponent) component).setWorkerPoolSize((int) value); return true;
            case "bridgeErrorHandler": ((SalesforceComponent) component).setBridgeErrorHandler((boolean) value); return true;
            case "fallbackToLatestReplayId": getOrCreateConfiguration((SalesforceComponent) component).setFallbackToLatestReplayId((boolean) value); return true;
            case "pubSubBatchSize": getOrCreateConfiguration((SalesforceComponent) component).setPubSubBatchSize((int) value); return true;
            case "pubSubDeserializeType": getOrCreateConfiguration((SalesforceComponent) component).setPubSubDeserializeType((org.apache.camel.component.salesforce.PubSubDeserializeType) value); return true;
            case "pubSubPojoClass": getOrCreateConfiguration((SalesforceComponent) component).setPubSubPojoClass((java.lang.String) value); return true;
            case "replayPreset": getOrCreateConfiguration((SalesforceComponent) component).setReplayPreset((com.salesforce.eventbus.protobuf.ReplayPreset) value); return true;
            case "consumerWorkerPoolEnabled": ((SalesforceComponent) component).setConsumerWorkerPoolEnabled((boolean) value); return true;
            case "consumerWorkerPoolExecutorService": ((SalesforceComponent) component).setConsumerWorkerPoolExecutorService((java.util.concurrent.ExecutorService) value); return true;
            case "consumerWorkerPoolMaxSize": ((SalesforceComponent) component).setConsumerWorkerPoolMaxSize((int) value); return true;
            case "consumerWorkerPoolSize": ((SalesforceComponent) component).setConsumerWorkerPoolSize((int) value); return true;
            case "initialReplyIdTimeout": ((SalesforceComponent) component).setInitialReplyIdTimeout((int) value); return true;
            case "allOrNone": getOrCreateConfiguration((SalesforceComponent) component).setAllOrNone((boolean) value); return true;
            case "apexUrl": getOrCreateConfiguration((SalesforceComponent) component).setApexUrl((java.lang.String) value); return true;
            case "compositeMethod": getOrCreateConfiguration((SalesforceComponent) component).setCompositeMethod((java.lang.String) value); return true;
            case "eventName": getOrCreateConfiguration((SalesforceComponent) component).setEventName((java.lang.String) value); return true;
            case "eventSchemaFormat": getOrCreateConfiguration((SalesforceComponent) component).setEventSchemaFormat((org.apache.camel.component.salesforce.internal.dto.EventSchemaFormatEnum) value); return true;
            case "eventSchemaId": getOrCreateConfiguration((SalesforceComponent) component).setEventSchemaId((java.lang.String) value); return true;
            case "lazyStartProducer": ((SalesforceComponent) component).setLazyStartProducer((boolean) value); return true;
            case "rawHttpHeaders": getOrCreateConfiguration((SalesforceComponent) component).setRawHttpHeaders((java.lang.String) value); return true;
            case "rawMethod": getOrCreateConfiguration((SalesforceComponent) component).setRawMethod((java.lang.String) value); return true;
            case "rawPath": getOrCreateConfiguration((SalesforceComponent) component).setRawPath((java.lang.String) value); return true;
            case "rawQueryParameters": getOrCreateConfiguration((SalesforceComponent) component).setRawQueryParameters((java.lang.String) value); return true;
            case "autowiredEnabled": ((SalesforceComponent) component).setAutowiredEnabled((boolean) value); return true;
            case "httpProxyExcludedAddresses": ((SalesforceComponent) component).setHttpProxyExcludedAddresses((java.util.Set) value); return true;
            case "httpProxyHost": ((SalesforceComponent) component).setHttpProxyHost((java.lang.String) value); return true;
            case "httpProxyIncludedAddresses": ((SalesforceComponent) component).setHttpProxyIncludedAddresses((java.util.Set) value); return true;
            case "httpProxyPort": ((SalesforceComponent) component).setHttpProxyPort((java.lang.Integer) value); return true;
            case "httpProxySocks4": ((SalesforceComponent) component).setHttpProxySocks4((boolean) value); return true;
            case "pubsubAllowUseSystemProxy": ((SalesforceComponent) component).setPubsubAllowUseSystemProxy((boolean) value); return true;
            case "authenticationType": ((SalesforceComponent) component).setAuthenticationType((org.apache.camel.component.salesforce.AuthenticationType) value); return true;
            case "clientId": ((SalesforceComponent) component).setClientId((java.lang.String) value); return true;
            case "clientSecret": ((SalesforceComponent) component).setClientSecret((java.lang.String) value); return true;
            case "httpProxyAuthUri": ((SalesforceComponent) component).setHttpProxyAuthUri((java.lang.String) value); return true;
            case "httpProxyPassword": ((SalesforceComponent) component).setHttpProxyPassword((java.lang.String) value); return true;
            case "httpProxyRealm": ((SalesforceComponent) component).setHttpProxyRealm((java.lang.String) value); return true;
            case "httpProxySecure": ((SalesforceComponent) component).setHttpProxySecure((boolean) value); return true;
            case "httpProxyUseDigestAuth": ((SalesforceComponent) component).setHttpProxyUseDigestAuth((boolean) value); return true;
            case "httpProxyUsername": ((SalesforceComponent) component).setHttpProxyUsername((java.lang.String) value); return true;
            case "instanceUrl": ((SalesforceComponent) component).setInstanceUrl((java.lang.String) value); return true;
            case "jwtAudience": ((SalesforceComponent) component).setJwtAudience((java.lang.String) value); return true;
            case "keystore": ((SalesforceComponent) component).setKeystore((org.apache.camel.support.jsse.KeyStoreParameters) value); return true;
            case "lazyLogin": ((SalesforceComponent) component).setLazyLogin((boolean) value); return true;
            case "loginConfig": ((SalesforceComponent) component).setLoginConfig((org.apache.camel.component.salesforce.SalesforceLoginConfig) value); return true;
            case "loginUrl": ((SalesforceComponent) component).setLoginUrl((java.lang.String) value); return true;
            case "password": ((SalesforceComponent) component).setPassword((java.lang.String) value); return true;
            case "pubSubHost": ((SalesforceComponent) component).setPubSubHost((java.lang.String) value); return true;
            case "pubSubPort": ((SalesforceComponent) component).setPubSubPort((int) value); return true;
            case "refreshToken": ((SalesforceComponent) component).setRefreshToken((java.lang.String) value); return true;
            case "sslContextParameters": ((SalesforceComponent) component).setSslContextParameters((org.apache.camel.support.jsse.SSLContextParameters) value); return true;
            case "useGlobalSslContextParameters": ((SalesforceComponent) component).setUseGlobalSslContextParameters((boolean) value); return true;
            case "userName": ((SalesforceComponent) component).setUserName((java.lang.String) value); return true;
            default: return false;
            }
        }

    public CreateIssueProducer(GitHubEndpoint endpoint) throws Exception {
        super(endpoint);

        Registry registry = endpoint.getCamelContext().getRegistry();
        Object service = registry.lookupByName(GitHubConstants.GITHUB_ISSUE_SERVICE);
        if (service != null) {
            issueService = (IssueService) service;
        } else {
            issueService = new IssueService();
        }
        initService(issueService);
    }

    public static List<MethodInfo> methods(IndexView view, ClassInfo type, Predicate<MethodInfo> filter) {
        List<MethodInfo> answer = new ArrayList<>();

        for (ClassInfo current = type; current != null;) {
            for (MethodInfo methodInfo : current.methods()) {
                if (filter.test(methodInfo)) {
                    answer.add(methodInfo);
                }
            }

            Type superType = current.superClassType();
            if (superType == null) {
                break;
            }

            current = view.getClassByName(superType.name());
        }

        return answer;
    }

    public static Expression fileNameNoExtensionExpression() {
        return new ExpressionAdapter() {
            @Override
            public Object evaluate(Exchange exchange) {
                String name = exchange.getIn().getHeader(Exchange.FILE_NAME, String.class);
                return FileUtil.stripExt(name);
            }

            @Override
            public String toString() {
                return "file:name.noext";
            }
        };
    }

    public String summaryErrorMessage(boolean includeHeader, boolean ignoreDeprecated, boolean includeWarnings) {
        boolean ok = isSuccess();

         
        if (ok && !ignoreDeprecated) {
            ok = deprecated == null;
        }

        if (includeWarnings) {
            if (incapable != null) {
                return "\tIncapable of parsing uri: " + incapable;
            } else if (syntaxError != null) {
                return "\tSyntax error: " + syntaxError;
            } else if (unknownComponent != null) {
                return "\tUnknown component: " + unknownComponent;
            }
        }

        if (ok) {
            return null;
        }

         
        Map<String, String> options = new LinkedHashMap<>();
        if (unknown != null) {
            for (String name : unknown) {
                if (unknownSuggestions != null && unknownSuggestions.containsKey(name)) {
                    String[] suggestions = unknownSuggestions.get(name);
                    if (suggestions != null && suggestions.length > 0) {
                        String str = Arrays.asList(suggestions).toString();
                        options.put(name, "Unknown option. Did you mean: " + str);
                    } else {
                        options.put(name, "Unknown option");
                    }
                } else {
                    options.put(name, "Unknown option");
                }
            }
        }
        if (notConsumerOnly != null) {
            for (String name : notConsumerOnly) {
                options.put(name, "Option not applicable in consumer only mode");
            }
        }
        if (notProducerOnly != null) {
            for (String name : notProducerOnly) {
                options.put(name, "Option not applicable in producer only mode");
            }
        }
        if (required != null) {
            for (String name : required) {
                options.put(name, "Missing required option");
            }
        }
        if (deprecated != null) {
            for (String name : deprecated) {
                options.put(name, "Deprecated option");
            }
        }
        if (invalidEnum != null) {
            for (Map.Entry<String, String> entry : invalidEnum.entrySet()) {
                String name = entry.getKey();
                String[] choices = invalidEnumChoices.get(name);
                String defaultValue = defaultValues != null ? defaultValues.get(entry.getKey()) : null;
                String str = Arrays.asList(choices).toString();
                String msg = "Invalid enum value: " + entry.getValue() + ". Possible values: " + str;
                if (invalidEnumSuggestions != null) {
                    String[] suggestions = invalidEnumSuggestions.get(name);
                    if (suggestions != null && suggestions.length > 0) {
                        str = Arrays.asList(suggestions).toString();
                        msg += ". Did you mean: " + str;
                    }
                }
                if (defaultValue != null) {
                    msg += ". Default value: " + defaultValue;
                }

                options.put(entry.getKey(), msg);
            }
        }
        if (invalidReference != null) {
            for (Map.Entry<String, String> entry : invalidReference.entrySet()) {
                boolean empty = isEmpty(entry.getValue());
                if (empty) {
                    options.put(entry.getKey(), "Empty reference value");
                } else if (!entry.getValue().startsWith("#")) {
                    options.put(entry.getKey(), "Invalid reference value: " + entry.getValue() + " must start with #");
                } else {
                    options.put(entry.getKey(), "Invalid reference value: " + entry.getValue());
                }
            }
        }
        if (invalidBoolean != null) {
            for (Map.Entry<String, String> entry : invalidBoolean.entrySet()) {
                boolean empty = isEmpty(entry.getValue());
                if (empty) {
                    options.put(entry.getKey(), "Empty boolean value");
                } else {
                    options.put(entry.getKey(), "Invalid boolean value: " + entry.getValue());
                }
            }
        }
        if (invalidInteger != null) {
            for (Map.Entry<String, String> entry : invalidInteger.entrySet()) {
                boolean empty = isEmpty(entry.getValue());
                if (empty) {
                    options.put(entry.getKey(), "Empty integer value");
                } else {
                    options.put(entry.getKey(), "Invalid integer value: " + entry.getValue());
                }
            }
        }
        if (invalidNumber != null) {
            for (Map.Entry<String, String> entry : invalidNumber.entrySet()) {
                boolean empty = isEmpty(entry.getValue());
                if (empty) {
                    options.put(entry.getKey(), "Empty number value");
                } else {
                    options.put(entry.getKey(), "Invalid number value: " + entry.getValue());
                }
            }
        }

         
         
        int maxLen = 24;
        for (String key : options.keySet()) {
            maxLen = Math.max(maxLen, key.length());
        }
        String format = "%" + maxLen + "s    %s";

         
        StringBuilder sb = new StringBuilder(512);
        if (includeHeader) {
            sb.append("Endpoint validator error\n");
            sb.append(
                    "---------------------------------------------------------------------------------------------------------------------------------------\n");
            sb.append("\n");
        }
        if (uri != null) {
            sb.append("\t").append(uri).append("\n");
        } else {
            sb.append("\n");
        }
        for (Map.Entry<String, String> option : options.entrySet()) {
            String out = String.format(format, option.getKey(), option.getValue());
            sb.append("\n\t").append(out);
        }

        return sb.toString();
    }

    private void insertRecord(Exchange exchange, String orgName, String bucketName, WritePrecision writePrecision)
            throws InvalidPayloadException {
        Record recordObj = exchange.getIn().getMandatoryBody(Record.class);
        try {
            if (LOG.isDebugEnabled()) {
                LOG.debug("Writing record {}", recordObj);
            }
            writeApi.writeRecord(bucketName, orgName, writePrecision, recordObj.getInfluxRecord());
        } catch (Exception ex) {
            exchange.setException(new CamelInfluxDb2Exception(ex));
        }
    }

    public static EventHubConsumerAsyncClient createEventHubConsumerAsyncClient(final EventHubsConfiguration configuration) {
        EventHubClientBuilder eventHubClientBuilder = new EventHubClientBuilder()
                .consumerGroup(configuration.getConsumerGroupName())
                .prefetchCount(configuration.getPrefetchCount())
                .transportType(configuration.getAmqpTransportType())
                .retryOptions(configuration.getAmqpRetryOptions());

        CredentialType type = configuration.getCredentialType();
        if (type == null) {
            type = CredentialType.CONNECTION_STRING;
        }
        if (CredentialType.CONNECTION_STRING.equals(type)) {
            return eventHubClientBuilder
                    .connectionString(buildConnectionString(configuration))
                    .buildAsyncConsumerClient();
        } else if (CredentialType.TOKEN_CREDENTIAL.equals(type)) {

            checkTokenCredentialConfiguration(configuration);
            return eventHubClientBuilder
                    .fullyQualifiedNamespace(getFullyQualifiedNamespace(configuration))
                    .eventHubName(configuration.getEventHubName())
                    .credential(configuration.getTokenCredential())
                    .buildAsyncConsumerClient();
        }
        return eventHubClientBuilder
                .fullyQualifiedNamespace(getFullyQualifiedNamespace(configuration))
                .eventHubName(configuration.getEventHubName())
                .credential(new DefaultAzureCredentialBuilder().build())
                .buildAsyncConsumerClient();
    }

    protected void setRegisterDeliveryReceiptFlag(SubmitSm[] submitSms, Message message) {
        byte specifiedDeliveryFlag = getRegisterDeliveryFlag(message);
        byte flag;
        if (getRequestsSingleDLR(message)) {
             
            flag = SMSCDeliveryReceipt.DEFAULT.value();
        } else {
            flag = specifiedDeliveryFlag;
        }

        for (int i = 0; i < submitSms.length - 1; i++) {
            submitSms[i].setRegisteredDelivery(flag);
        }
        submitSms[submitSms.length - 1].setRegisteredDelivery(specifiedDeliveryFlag);
    }

    protected int poll() throws Exception {
         
        final Map<String, Object> args = new HashMap<>(endpoint.getEndpointProperties());

         
        endpoint.interceptProperties(args);
        interceptProperties(args);

        try {
             
            final CountDownLatch latch = new CountDownLatch(1);
            final Object[] result = new Object[1];
            final Exception[] error = new Exception[1];

            args.put(Olingo4Endpoint.RESPONSE_HANDLER_PROPERTY, new Olingo4ResponseHandler<Object>() {
                @Override
                public void onResponse(Object response, Map<String, String> responseHeaders) {
                    if (resultIndex != null) {
                        response = resultIndex.filterResponse(response);
                    }

                    result[0] = response;
                    latch.countDown();
                }

                @Override
                public void onException(Exception ex) {
                    error[0] = ex;
                    latch.countDown();
                }

                @Override
                public void onCanceled() {
                    error[0] = new RuntimeCamelException("OData HTTP Request cancelled");
                    latch.countDown();
                }
            });

            doInvokeMethod(args);

             
             
            latch.await();

            if (error[0] != null) {
                throw error[0];
            }

             
             
             
             
            if (result[0] == null
                    || result[0] instanceof ClientEntitySet && (((ClientEntitySet) result[0]).getEntities().isEmpty())) {
                return 0;
            } else {
                return ApiConsumerHelper.getResultsProcessed(this, result[0], isSplitResult());
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        } catch (Exception e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        }
    }

    public void getQueryResult(
            String jobId, String batchId, String resultId, Map<String, List<String>> headers,
            final StreamResponseCallback callback) {
        final Request get = getRequest(HttpMethod.GET, batchResultUrl(jobId, batchId, resultId), headers);

         
        doHttpRequest(get, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                callback.onResponse(response, headers, ex);
            }
        });
    }

    public Calendar makeClient(
            CamelContext camelContext, String serviceAccountKey, Collection<String> scopes, String applicationName,
            String delegate) {
        if (serviceAccountKey == null) {
            throw new IllegalArgumentException("serviceAccountKey is required to create Google Calendar client.");
        }
        try {
            Credential credential = authorizeServiceAccount(camelContext, serviceAccountKey, delegate, scopes);
            return new Calendar.Builder(transport, jsonFactory, credential).setApplicationName(applicationName).build();
        } catch (Exception e) {
            throw new RuntimeCamelException("Could not create Google Calendar client.", e);
        }
    }

        protected void onExceptionOccurred() {
            if (onExceptionProcessor == null) {
                return;
            }

             
            try {
                if (LOG.isTraceEnabled()) {
                    LOG.trace("OnExceptionOccurred processor {} is processing Exchange: {} due exception occurred",
                            onExceptionProcessor, exchange);
                }
                onExceptionProcessor.process(exchange);
            } catch (Exception e) {
                 
                LOG.warn("Error during processing OnExceptionOccurred. This exception is ignored.", e);
            }
            LOG.trace("OnExceptionOccurred processor done");
        }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        OpenAIConfiguration configuration = new OpenAIConfiguration();

        if (apiKey != null) {
            configuration.setApiKey(apiKey);
        }
        if (baseUrl != null) {
            configuration.setBaseUrl(baseUrl);
        }
        if (model != null) {
            configuration.setModel(model);
        }

        OpenAIEndpoint endpoint = new OpenAIEndpoint(uri, this, configuration);
         
        endpoint.setOperation(remaining);
        setProperties(endpoint, parameters);

        return endpoint;
    }

    private void delete(Exchange exchange) throws Exception {
        final Message in = exchange.getMessage();

        String collectionName = getCollectionName(in);
        Collection collection = this.client.getCollection(collectionName, embeddingFunction);

        List<String> ids = in.getHeader(ChromaHeaders.IDS, List.class);
        Map<String, Object> where = in.getHeader(ChromaHeaders.WHERE, Map.class);
        Map<String, Object> whereDocument = in.getHeader(ChromaHeaders.WHERE_DOCUMENT, Map.class);

        collection.delete(ids, where, whereDocument);
        in.setHeader(ChromaHeaders.OPERATION_STATUS, "SUCCESS");
    }

  final public Token InParameterSrc() throws ParseException {Token ret = null;
    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
    case SIMPLE_EXP_TOKEN:{
      ret = jj_consume_token(SIMPLE_EXP_TOKEN);
{if ("" != null) return ret;}
      break;
      }
    case PARAMETER_POS_TOKEN:{
      ret = jj_consume_token(PARAMETER_POS_TOKEN);
{if ("" != null) return ret;}
      break;
      }
    default:
      jj_la1[11] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
}

    private static GenericFileExclusiveReadLockStrategy<FileIdBothDirectoryInformation> getExclusiveReadLockStrategy(
            Map<String, Object> params) {
        GenericFileExclusiveReadLockStrategy<FileIdBothDirectoryInformation> strategy
                = (GenericFileExclusiveReadLockStrategy<FileIdBothDirectoryInformation>) params
                        .get("exclusiveReadLockStrategy");
        if (strategy != null) {
            return strategy;
        }

         
        String readLock = (String) params.get("readLock");
        if (ObjectHelper.isNotEmpty(readLock)) {
            if ("none".equals(readLock) || "false".equals(readLock)) {
                return null;
            } else if ("rename".equals(readLock)) {
                GenericFileRenameExclusiveReadLockStrategy<FileIdBothDirectoryInformation> readLockStrategy
                        = new GenericFileRenameExclusiveReadLockStrategy<>();
                StrategyUtil.setup(readLockStrategy, params);
                return readLockStrategy;
            } else if ("changed".equals(readLock)) {
                SmbChangedExclusiveReadLockStrategy readLockStrategy = new SmbChangedExclusiveReadLockStrategy();
                StrategyUtil.setup(readLockStrategy, params);
                return readLockStrategy;
            }
        }

        return null;
    }

    public void onBeginDownloading(String host, String file) {
        download = true;
        resume = false;
        resumeOffset = 0;
        watch.restart();
        interval.restart();
        String msg = "Downloading from host: " + host + " file: " + file + " starting ";  
                                                                                         
                                                                                         
                                                                                         
                                                                                         
                                                                                         
                                                                                         
        if (fileSize > 0) {
            msg += " (size: " + fileSizeText + ")";
        }
        doLog(msg);
    }

    private void createClientRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).roles().create((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client role created successfully");
            }
        } else {
            RoleRepresentation role = new RoleRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME))) {
                String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
                role.setName(roleName);

                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION))) {
                    role.setDescription(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION, String.class));
                }
            } else {
                throw new IllegalArgumentException(MISSING_ROLE_NAME);
            }
            keycloakClient.realm(realmName).clients().get(clientUuid).roles().create(role);
            Message message = getMessageForResponse(exchange);
            message.setBody("Client role created successfully");
        }
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        try {
            Object newProperty = expression.evaluate(exchange, Object.class);

            if (exchange.getException() != null) {
                 
                callback.done(true);
                return true;
            }

            String key = propertyName.evaluate(exchange, String.class);
            exchange.setProperty(key, newProperty);
        } catch (Exception e) {
            exchange.setException(e);
        }

        callback.done(true);
        return true;
    }

    protected RouteConfigurationDefinition createRouteConfiguration(String id) {
        RouteConfigurationDefinition config = new RouteConfigurationDefinition();
        if (id != null) {
            config.setId(id);
        }
        if (resource != null) {
            config.setResource(resource);
        }
        CamelContextAware.trySetCamelContext(config, camelContext);
        return config;
    }

    private void insertMeasurements(Exchange exchange, String orgName, String bucketName, WritePrecision writePrecision)
            throws InvalidPayloadException {
        Measurements measurements = exchange.getIn().getMandatoryBody(Measurements.class);
        try {
            if (LOG.isDebugEnabled()) {
                LOG.debug("Writing measurements {}", measurements);
            }
            writeApi.writeMeasurements(bucketName, orgName, writePrecision, measurements.getInfluxMeasurements());
        } catch (Exception ex) {
            exchange.setException(new CamelInfluxDb2Exception(ex));
        }
    }

    public static Expression fileExtensionSingleExpression() {
        return new ExpressionAdapter() {
            @Override
            public Object evaluate(Exchange exchange) {
                String name = exchange.getIn().getHeader(Exchange.FILE_NAME, String.class);
                return FileUtil.onlyExt(name, true);
            }

            @Override
            public String toString() {
                return "file:ext.single";
            }
        };
    }

    public CamelPathTemplateHandler add(final String uriTemplate, final CamelMethodHandler handler) {
        lock.lock();
        try {
            delegate.add(uriTemplate, handler);
            handlers.put(uriTemplate, handler);
            handlerString = null;
            return this;
        } finally {
            lock.unlock();
        }
    }

    public <T extends ManagedProcessorMBean> T getManagedProcessor(String id, Class<T> type) {
         
        if (getManagementStrategy().getManagementAgent() == null) {
            return null;
        }

        Processor processor = camelContext.getProcessor(id);
        ProcessorDefinition<?> def
                = camelContext.getCamelContextExtension().getContextPlugin(Model.class).getProcessorDefinition(id);

         
        if (def != null) {
            try {
                ObjectName on = getManagementStrategy().getManagementObjectNameStrategy()
                        .getObjectNameForProcessor(camelContext, processor, def);
                return getManagementStrategy().getManagementAgent().newProxyClient(on, type);
            } catch (MalformedObjectNameException e) {
                throw RuntimeCamelException.wrapRuntimeCamelException(e);
            }
        }

        return null;
    }

    public GoogleDriveConfiguration getEndpointConfiguration(GoogleDriveApiName apiName) {
        GoogleDriveConfiguration result = null;
        switch (apiName) {
            case DRIVE_ABOUT:
                result = new DriveAboutEndpointConfiguration();
                break;
            case DRIVE_CHANGES:
                result = new DriveChangesEndpointConfiguration();
                break;
            case DRIVE_CHANNELS:
                result = new DriveChannelsEndpointConfiguration();
                break;
            case DRIVE_COMMENTS:
                result = new DriveCommentsEndpointConfiguration();
                break;
            case DRIVE_DRIVES:
                result = new DriveDrivesEndpointConfiguration();
                break;
            case DRIVE_FILES:
                result = new DriveFilesEndpointConfiguration();
                break;
            case DRIVE_PERMISSIONS:
                result = new DrivePermissionsEndpointConfiguration();
                break;
            case DRIVE_REPLIES:
                result = new DriveRepliesEndpointConfiguration();
                break;
            case DRIVE_REVISIONS:
                result = new DriveRevisionsEndpointConfiguration();
                break;
            case DRIVE_TEAMDRIVES:
                result = new DriveTeamdrivesEndpointConfiguration();
                break;
        }
        return result;
    }

    public boolean contains(final Exchange exchange, final String messageId) {
        final EntityManager entityManager
                = getTargetEntityManager(exchange, entityManagerFactory, true, sharedEntityManager, true);

         
        final Boolean[] rc = new Boolean[1];
        transactionStrategy.executeInTransaction(() -> {
            if (isJoinTransaction()) {
                entityManager.joinTransaction();
            }
            try {
                List<?> list = query(entityManager, messageId);
                if (list.isEmpty()) {
                    rc[0] = Boolean.FALSE;
                } else {
                    rc[0] = Boolean.TRUE;
                }
            } catch (Exception ex) {
                String contextInfo = String.format(SOMETHING_WENT_WRONG, ex.getMessage());
                throw new PersistenceException(contextInfo, ex);
            } finally {
                try {
                    if (entityManager.isOpen()) {
                        entityManager.close();
                    }
                } catch (Exception e) {
                     
                }
            }
        });

        LOG.debug("contains {} -> {}", messageId, rc[0]);
        return rc[0];
    }

    protected void doStart() throws Exception {
        super.doStart();

        String accessKey = System.getenv(CAMEL_AWS_VAULT_ACCESS_KEY_ENV);
        String secretKey = System.getenv(CAMEL_AWS_VAULT_SECRET_KEY_ENV);
        String region = System.getenv(CAMEL_AWS_VAULT_REGION_ENV);
        boolean useDefaultCredentialsProvider
                = Boolean.parseBoolean(System.getenv(CAMEL_AWS_VAULT_USE_DEFAULT_CREDENTIALS_PROVIDER_ENV));
        boolean useProfileCredentialsProvider
                = Boolean.parseBoolean(System.getenv(CAMEL_AWS_VAULT_USE_PROFILE_CREDENTIALS_PROVIDER_ENV));
        String profileName = System.getenv(CAMEL_AWS_VAULT_PROFILE_NAME_ENV);
        boolean isOverrideEndpoint = Boolean.parseBoolean(System.getenv(CAMEL_AWS_VAULT_IS_OVERRIDE_ENDPOINT));
        String uriEndpointOverride = System.getenv(CAMEL_AWS_VAULT_URI_ENDPOINT_OVERRIDE);
        if (ObjectHelper.isEmpty(accessKey) && ObjectHelper.isEmpty(secretKey) && ObjectHelper.isEmpty(region)) {
            AwsVaultConfiguration awsVaultConfiguration = getCamelContext().getVaultConfiguration().aws();
            if (ObjectHelper.isNotEmpty(awsVaultConfiguration)) {
                accessKey = awsVaultConfiguration.getAccessKey();
                secretKey = awsVaultConfiguration.getSecretKey();
                region = awsVaultConfiguration.getRegion();
                useDefaultCredentialsProvider = awsVaultConfiguration.isDefaultCredentialsProvider();
                useProfileCredentialsProvider = awsVaultConfiguration.isProfileCredentialsProvider();
                profileName = awsVaultConfiguration.getProfileName();
                isOverrideEndpoint = awsVaultConfiguration.isOverrideEndpoint();
                uriEndpointOverride = awsVaultConfiguration.getUriEndpointOverride();
            }
        }
        this.region = region;
        if (ObjectHelper.isNotEmpty(accessKey) && ObjectHelper.isNotEmpty(secretKey) && ObjectHelper.isNotEmpty(region)) {
            SecretsManagerClientBuilder clientBuilder = SecretsManagerClient.builder();
            AwsBasicCredentials cred = AwsBasicCredentials.create(accessKey, secretKey);
            clientBuilder = clientBuilder.credentialsProvider(StaticCredentialsProvider.create(cred));
            clientBuilder.region(Region.of(region));
            if (isOverrideEndpoint) {
                if (ObjectHelper.isNotEmpty(uriEndpointOverride)) {
                    clientBuilder.endpointOverride(URI.create(uriEndpointOverride));
                }
            }
            client = clientBuilder.build();
        } else if (useDefaultCredentialsProvider && ObjectHelper.isNotEmpty(region)) {
            this.defaultCredentialsProvider = true;
            SecretsManagerClientBuilder clientBuilder = SecretsManagerClient.builder();
            clientBuilder.region(Region.of(region));
            if (isOverrideEndpoint) {
                if (ObjectHelper.isNotEmpty(uriEndpointOverride)) {
                    clientBuilder.endpointOverride(URI.create(uriEndpointOverride));
                }
            }
            client = clientBuilder.build();
        } else if (useProfileCredentialsProvider && ObjectHelper.isNotEmpty(profileName)) {
            this.profleCredentialsProvider = true;
            this.profileName = profileName;
            SecretsManagerClientBuilder clientBuilder = SecretsManagerClient.builder();
            clientBuilder.credentialsProvider(ProfileCredentialsProvider.create(profileName));
            clientBuilder.region(Region.of(region));
            if (isOverrideEndpoint) {
                if (ObjectHelper.isNotEmpty(uriEndpointOverride)) {
                    clientBuilder.endpointOverride(URI.create(uriEndpointOverride));
                }
            }
            client = clientBuilder.build();
        } else {
            throw new RuntimeCamelException(
                    "Using the AWS Secrets Manager Properties Function requires setting AWS credentials as application properties or environment variables");
        }
    }

    public String getJBangJsonSchema() {
        String path = "META-INF/camel-jbang-configuration-metadata.json";
        InputStream is = null;
        if (classLoader != null) {
            is = classLoader.getResourceAsStream(path);
        }
        if (is == null) {
            ClassResolver resolver = camelContext.getClassResolver();
            is = resolver.loadResourceAsStream(path);
        }
        if (is != null) {
            try {
                return IOHelper.loadText(is);
            } catch (IOException e) {
                 
            } finally {
                IOHelper.close(is);
            }
        }
        return null;
    }

    protected void doPushTag(Exchange exchange, String operation) throws GitAPIException {
        Iterable<PushResult> result = null;
        try {
            if (ObjectHelper.isEmpty(endpoint.getRemoteName())) {
                throw new IllegalArgumentException("Remote name must be specified to execute " + operation);
            }
            if (ObjectHelper.isEmpty(endpoint.getTagName())) {
                throw new IllegalArgumentException("Tag Name must be specified to execute " + operation);
            }
            if (ObjectHelper.isNotEmpty(endpoint.getUsername()) && ObjectHelper.isNotEmpty(endpoint.getPassword())) {
                UsernamePasswordCredentialsProvider credentials
                        = new UsernamePasswordCredentialsProvider(endpoint.getUsername(), endpoint.getPassword());
                result = git.push().setCredentialsProvider(credentials).setRemote(endpoint.getRemoteName())
                        .add(Constants.R_TAGS + endpoint.getTagName()).call();
            } else {
                result = git.push().setRemote(endpoint.getRemoteName()).add(Constants.R_TAGS + endpoint.getTagName()).call();
            }
        } catch (GitAPIException e) {
            LOG.error("There was an error in Git {} operation", operation);
            throw e;
        }
        updateExchange(exchange, result);
    }

    public int forceDiscardingOfGroup(String key) {
         
        int total = 0;

        lock.lock();
        try {
            Exchange exchange = aggregationRepository.get(camelContext, key);
            if (exchange != null) {
                total = 1;
                LOG.trace("Force discarded triggered for correlation key: {}", key);
                 
                onCompletion(key, exchange, exchange, false, true);
            }
        } finally {
            lock.unlock();
        }
        LOG.trace("Completed force discarded of group {}", key);

        if (total > 0) {
            LOG.debug("Forcing discarding of group {} with {} exchanges", key, total);
        }
        return total;
    }

    JsonObject loadStatus(long pid) {
        try {
            Path f = getStatusFile(Long.toString(pid));
            if (f != null && Files.exists(f)) {
                String text = Files.readString(f);
                return (JsonObject) Jsoner.deserialize(text);
            }
        } catch (Exception e) {
             
        }
        return null;
    }

    private SmnClient initializeClient(ClientConfigurations clientConfigurations) {
        if (LOG.isDebugEnabled()) {
            LOG.debug("Initializing Smn client");
        }
        HttpConfig httpConfig
                = HttpConfig.getDefaultHttpConfig().withIgnoreSSLVerification(clientConfigurations.isIgnoreSslVerification());
        if (!StringUtils.isEmpty(clientConfigurations.getProxyHost())) {
            httpConfig.setProxyHost(clientConfigurations.getProxyHost());
            httpConfig.setProxyPort(clientConfigurations.getProxyPort());
            if (!StringUtils.isEmpty(clientConfigurations.getProxyUser())) {
                httpConfig.setProxyUsername(clientConfigurations.getProxyUser());
                httpConfig.setProxyPassword(clientConfigurations.getProxyPassword());
            }
        }

        BasicCredentials credentials = new BasicCredentials()
                .withAk(clientConfigurations.getAccessKey())
                .withSk(clientConfigurations.getSecretKey())
                .withProjectId(clientConfigurations.getProjectId());

        if (LOG.isDebugEnabled()) {
            LOG.debug("Building Smn client");
        }

         
        SmnClient smnClient = SmnClient.newBuilder()
                .withCredential(credentials)
                .withHttpConfig(httpConfig)
                .withEndpoint(clientConfigurations.getServiceEndpoint())
                .build();

        if (LOG.isDebugEnabled()) {
            LOG.debug("Successfully initialized Smn client");
        }
        return smnClient;
    }

    private boolean updateOptionsIn(final File file, final String kind, final String changed) throws MojoExecutionException {
        if (!file.exists()) {
            return false;
        }

        final String updated = changed.trim();
        try {
            String text = PackageHelper.loadText(file);

            String existing = Strings.between(text, "// " + kind + " options: START", "// " + kind + " options: END");
            if (existing != null) {
                 
                existing = existing.trim();
                if (existing.equals(updated)) {
                    return false;
                }

                String before = Strings.before(text, "// " + kind + " options: START");
                String after = Strings.after(text, "// " + kind + " options: END");
                text = before + "// " + kind + " options: START\n" + updated + "\n// " + kind + " options: END" + after;
                PackageHelper.writeText(file, text);
                return true;
            }

            getLog().warn("Cannot find markers in file " + file);
            getLog().warn("Add the following markers");
            getLog().warn("\t// " + kind + " options: START");
            getLog().warn("\t// " + kind + " options: END");
            return false;
        } catch (IOException e) {
            throw new MojoExecutionException("Error reading file " + file + " Reason: " + e, e);
        }
    }

    protected void doListJobByLabel(Exchange exchange) {
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        Map<String, String> labels = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_JOB_LABELS, Map.class);
        JobList jobList;

        if (ObjectHelper.isEmpty(labels)) {
            LOG.error("Get Job by labels require specify a labels set");
            throw new IllegalArgumentException("Get Job by labels require specify a labels set");
        }

        if (ObjectHelper.isEmpty(namespace)) {
            jobList = getEndpoint().getKubernetesClient().batch().v1().jobs().inAnyNamespace().withLabels(labels).list();
        } else {
            jobList = getEndpoint().getKubernetesClient().batch().v1().jobs().inNamespace(namespace).withLabels(labels).list();
        }

        prepareOutboundMessage(exchange, jobList.getItems());
    }

    public <T> T convertTo(Class<?> from, Class<T> to, Exchange exchange, Object value) throws TypeConversionException {
        try {
            Object obj = doConvertTo(from, to, exchange, value);
            return (T) obj;
        } catch (TypeConversionException e) {
            throw e;
        } catch (Exception e) {
            throw new TypeConversionException(value, to, e);
        }
    }

    public boolean register(DevConsole console) {
        boolean result;
         
        if (getConsole(console.getId()).isPresent()) {
            return false;
        }
        result = consoles.add(console);
        if (result) {
            CamelContextAware.trySetCamelContext(console, camelContext);
             
            ServiceHelper.startService(console);
            LOG.debug("DevConsole with id {} successfully registered", console.getId());
        }
        return result;
    }

    public AS2Configuration getEndpointConfiguration(AS2ApiName apiName) {
        AS2Configuration result = null;
        switch (apiName) {
            case CLIENT:
                result = new AS2ClientManagerEndpointConfiguration();
                break;
            case SERVER:
                result = new AS2ServerManagerEndpointConfiguration();
                break;
            case RECEIPT:
                result = new AS2AsyncMDNServerManagerEndpointConfiguration();
                break;
        }
        return result;
    }

    protected SubmitMulti[] createSubmitMulti(Exchange exchange) throws SmppException {
        Message message = exchange.getIn();
        byte[][] segments = splitBody(message);
        SubmitMulti template = createSubmitMultiTemplate(exchange);

         
        ESMClass esmClass = message.getHeader(SmppConstants.ESM_CLASS, ESMClass.class);
        if (esmClass != null) {
            template.setEsmClass(esmClass.value());
        } else if (segments.length > 1) {
             
            template.setEsmClass(new ESMClass(MessageMode.DEFAULT, MessageType.DEFAULT, GSMSpecificFeature.UDHI).value());
        }

        SubmitMulti[] submitMulties = new SubmitMulti[segments.length];
        for (int i = 0; i < segments.length; i++) {
            SubmitMulti submitMulti = SmppUtils.copySubmitMulti(template);
            submitMulti.setShortMessage(segments[i]);
            submitMulties[i] = submitMulti;
        }

        setRegisterDeliveryReceiptFlag(submitMulties, message);
        return submitMulties;
    }

    private void createClientRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).roles().create((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client role created successfully");
            }
        } else {
            RoleRepresentation role = new RoleRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME))) {
                String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
                role.setName(roleName);

                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION))) {
                    role.setDescription(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION, String.class));
                }
            } else {
                throw new IllegalArgumentException(MISSING_ROLE_NAME);
            }
            keycloakClient.realm(realmName).clients().get(clientUuid).roles().create(role);
            Message message = getMessageForResponse(exchange);
            message.setBody("Client role created successfully");
        }
    }

    private CredentialsProvider getCredentialsProvider(GooglePubsubEndpoint endpoint) throws IOException {
        CredentialsProvider credentialsProvider;

        if (endpoint.isAuthenticate()) {
            credentialsProvider = FixedCredentialsProvider.create(ObjectHelper.isEmpty(endpoint.getServiceAccountKey())
                    ? GoogleCredentials.getApplicationDefault() : ServiceAccountCredentials.fromStream(ResourceHelper
                            .resolveMandatoryResourceAsInputStream(getCamelContext(), endpoint.getServiceAccountKey()))
                            .createScoped(PublisherStubSettings.getDefaultServiceScopes()));
        } else {
            credentialsProvider = NoCredentialsProvider.create();
        }

        return credentialsProvider;
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        final EventHubsConfiguration configuration = this.configuration.copy();

        final EventHubsEndpoint endpoint = new EventHubsEndpoint(uri, this, configuration);
        setProperties(endpoint, parameters);

         
        if (isTokenCredentialSet(configuration)
                || !isProducerAsyncClientSet(configuration) && !isConnectionStringSet(configuration)) {
            checkAndSetNamespaceAndHubName(configuration, remaining);
        }

         
        if (endpoint.getConfiguration().getTokenCredential() == null) {
            if (endpoint.getConfiguration().getCredentialType() == null) {
                endpoint.getConfiguration().setCredentialType(CredentialType.CONNECTION_STRING);
            }
        } else {
            boolean azure = endpoint.getConfiguration().getTokenCredential() instanceof DefaultAzureCredential;
            endpoint.getConfiguration()
                    .setCredentialType(azure ? CredentialType.AZURE_IDENTITY : CredentialType.TOKEN_CREDENTIAL);
        }

        validateConfigurations(configuration);

        return endpoint;
    }

    private void doCreateOrUpdateNode(Exchange exchange, String operationName, Function<Resource<Node>, Node> operation) {
        String nodeName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NODE_NAME, String.class);
        NodeSpec nodeSpec = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NODE_SPEC, NodeSpec.class);
        if (ObjectHelper.isEmpty(nodeName)) {
            LOG.error("{} a specific node require specify a node name", operationName);
            throw new IllegalArgumentException(String.format("%s a specific node require specify a node name", operationName));
        }
        if (ObjectHelper.isEmpty(nodeSpec)) {
            LOG.error("{} a specific node require specify a node spec bean", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific node require specify a node spec bean", operationName));
        }
        Map<String, String> labels = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_PODS_LABELS, Map.class);
        Node nodeCreating = new NodeBuilder().withNewMetadata().withName(nodeName).withLabels(labels).endMetadata()
                .withSpec(nodeSpec).build();
        Node node = operation.apply(getEndpoint().getKubernetesClient().nodes().resource(nodeCreating));

        prepareOutboundMessage(exchange, node);
    }

    public int forceCompletionOfGroup(String key) {
         
        int total = 0;

        lock.lock();
        try {
            Exchange exchange = aggregationRepository.get(camelContext, key);
            if (exchange != null) {
                total = 1;
                LOG.trace("Force completion triggered for correlation key: {}", key);
                 
                exchange.setProperty(ExchangePropertyKey.AGGREGATED_COMPLETED_BY, COMPLETED_BY_FORCE);
                Exchange answer = onCompletion(key, exchange, exchange, false, false);
                if (answer != null) {
                    onSubmitCompletion(key, answer);
                }
            }
        } finally {
            lock.unlock();
        }
        LOG.trace("Completed force completion of group {}", key);

        if (total > 0) {
            LOG.debug("Forcing completion of group {} with {} exchanges", key, total);
        }
        return total;
    }

    public static Predicate contains(final Expression left, final Expression right) {
        return new BinaryPredicateSupport(left, right) {

            protected boolean matches(Exchange exchange, Object leftValue, Object rightValue) {
                if (leftValue == null && rightValue == null) {
                     
                    return true;
                } else if (leftValue == null || rightValue == null) {
                     
                    return false;
                }

                return ObjectHelper.typeCoerceContains(exchange.getContext().getTypeConverter(), leftValue, rightValue, false);
            }

            protected String getOperationText() {
                return "contains";
            }
        };
    }

    public void removeConsumer(String key, KameletConsumer consumer) {
        consumersLock.lock();
        try {
            consumers.remove(key, consumer);
             
            stateCounter++;
            consumersCondition.signalAll();
        } finally {
            consumersLock.unlock();
        }
    }

    private Olingo4ApiCollection() {
        final Map<String, String> aliases = new HashMap<>();
        final Map<Olingo4ApiName, ApiMethodHelper<? extends ApiMethod>> apiHelpers = new EnumMap<>(Olingo4ApiName.class);
        final Map<Class<? extends ApiMethod>, Olingo4ApiName> apiMethods = new HashMap<>();

        List<String> nullableArgs;

        aliases.clear();
        nullableArgs = Arrays.asList("queryParams", "endpointHttpHeaders", "edm", "responseHandler", "data");
        apiHelpers.put(Olingo4ApiName.DEFAULT, new ApiMethodHelper<>(Olingo4AppApiMethod.class, aliases, nullableArgs));
        apiMethods.put(Olingo4AppApiMethod.class, Olingo4ApiName.DEFAULT);

        setApiHelpers(apiHelpers);
        setApiMethods(apiMethods);
    }

    public String dumpStatisticsAsJson() {
        ObjectWriter writer = mapper.writer();
        if (isPrettyPrint()) {
            writer = writer.withDefaultPrettyPrinter();
        }
        try {
            return writer.writeValueAsString(getMeterRegistry());
        } catch (JsonProcessingException e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        }
    }

    protected void doStop() throws Exception {
        super.doStop();

        try {
            if (this.usm != null) {
                SecurityModels.getInstance().removeSecurityModel(new Integer32(this.usm.getID()));
            }
        } finally {
            this.targetAddress = null;
            this.usm = null;
            this.target = null;
        }
    }

    public static List<RestServiceDetails> parseRestService(
            JavaClassSource clazz, String fullyQualifiedFileName,
            boolean includeInlinedRouteBuilders) {

        List<MethodSource<JavaClassSource>> methods = findAllConfigureMethods(clazz, includeInlinedRouteBuilders);

        CamelJavaRestDslParserHelper parser = new CamelJavaRestDslParserHelper();
        List<RestServiceDetails> list = new ArrayList<>();
        for (MethodSource<JavaClassSource> configureMethod : methods) {
             
            List<RestServiceDetails> details = parser.parseRestService(clazz, fullyQualifiedFileName, configureMethod);
            list.addAll(details);
        }
         
        Collections.reverse(list);

        return list;
    }

    private static Map<String, Object> checkValidExchangePropertyObjects(
            String type, Exchange exchange, Map<String, Object> map, boolean allowSerializedValues) {
        if (map == null) {
            return null;
        }

        Map<String, Object> result = new LinkedHashMap<>();
        for (Map.Entry<String, Object> entry : map.entrySet()) {

             
            if (entry.getValue() == null) {
                continue;
            }

            Object value = getValidExchangePropertyValue(entry.getKey(), entry.getValue(), allowSerializedValues);
            if (value != null) {
                Serializable converted
                        = exchange.getContext().getTypeConverter().convertTo(Serializable.class, exchange, value);
                if (converted != null) {
                    result.put(entry.getKey(), converted);
                } else {
                    logCannotSerializeObject(type, entry.getKey(), entry.getValue());
                }
            } else {
                logInvalidExchangePropertyValue(type, entry.getKey(), entry.getValue());
            }
        }

        return result;
    }

    public Processor createProcessor() throws Exception {
        if (definition.getVariables().isEmpty()) {
            throw new IllegalArgumentException("There must be at least one variable specified");
        }
        List<Expression> nameExprs = new java.util.ArrayList<>(definition.getVariables().size());
        List<Expression> valueExprs = new java.util.ArrayList<>(definition.getVariables().size());
        for (SetVariableDefinition varDef : definition.getVariables()) {
            valueExprs.add(createExpression(varDef.getExpression()));
            Expression nameExpr;
            String key = parseString(varDef.getName());
            if (LanguageSupport.hasSimpleFunction(key)) {
                nameExpr = camelContext.resolveLanguage("simple").createExpression(key);
            } else {
                nameExpr = camelContext.resolveLanguage("constant").createExpression(key);
            }
            nameExpr.init(camelContext);
            nameExprs.add(nameExpr);
        }

        SetVariablesProcessor answer = new SetVariablesProcessor(nameExprs, valueExprs);
        answer.setDisabled(isDisabled(camelContext, definition));
        return answer;
    }

    protected Class<?> getResponseModel(Message message, String modelName) {
        Class<?> model = null;

        if (message != null) {
            model = message.getHeader(ServiceNowConstants.RESPONSE_MODEL, Class.class);
            if (model == null) {
                model = message.getHeader(ServiceNowConstants.MODEL, Class.class);
            }
        }

        return model != null
                ? model
                : ObjectHelper.isEmpty(modelName) ? Map.class : config.getResponseModel(modelName, Map.class);
    }

    public int read(byte[] b, int off, int len) throws IOException {
        int tlen = 0;
        while (len > 0) {
            int n = ensureBuffering(len);
            if (n < 0) {
                break;
            }
            int clen = Math.min(len, n);
            System.arraycopy(buffer, 0, b, off, clen);
            System.arraycopy(buffer, clen, buffer, 0, buffer.length - clen);
            bpos -= clen;
            len -= clen;
            off += clen;
            tlen += clen;
        }

        return tlen > 0 ? tlen : -1;
    }

    public void toJson(final Writer writable) throws IOException {
         
        boolean isFirstEntry = true;
        final Iterator<Map.Entry<String, Object>> entries = this.entrySet().iterator();
        writable.write('{');
        while (entries.hasNext()) {
            if (isFirstEntry) {
                isFirstEntry = false;
            } else {
                writable.write(',');
            }
            final Map.Entry<String, Object> entry = entries.next();
            Jsoner.serialize(entry.getKey(), writable);
            writable.write(':');
            Jsoner.serialize(entry.getValue(), writable);
        }
        writable.write('}');
    }

    private void initFixedLengthRecordParameters() {

        for (Class<?> cl : models) {

             
            FixedLengthRecord fixedLengthRecord = cl.getAnnotation(FixedLengthRecord.class);

            if (fixedLengthRecord != null) {
                LOG.debug("Fixed length record: {}", fixedLengthRecord);

                 
                crlf = fixedLengthRecord.crlf();
                LOG.debug("Carriage return defined for the CSV: {}", crlf);

                eol = fixedLengthRecord.eol();
                LOG.debug("EOL(end-of-line) defined for the CSV: {}", eol);

                 
                header = fixedLengthRecord.header();
                LOG.debug("Header: {}", header);
                hasHeader = header != void.class;
                LOG.debug("Has Header: {}", hasHeader);

                 
                skipHeader = fixedLengthRecord.skipHeader();
                LOG.debug("Skip Header: {}", skipHeader);

                 
                footer = fixedLengthRecord.footer();
                LOG.debug("Footer: {}", footer);
                hasFooter = fixedLengthRecord.footer() != void.class;
                LOG.debug("Has Footer: {}", hasFooter);

                 
                skipFooter = fixedLengthRecord.skipFooter();
                LOG.debug("Skip Footer: {}", skipFooter);

                 
                isHeader = hasHeader && cl.equals(header);
                LOG.debug("Is Header: {}", isHeader);

                 
                isFooter = hasFooter && cl.equals(footer);
                LOG.debug("Is Footer: {}", isFooter);

                 
                paddingChar = fixedLengthRecord.paddingChar();
                LOG.debug("Padding char: {}", paddingChar);

                 
                recordLength = fixedLengthRecord.length();
                LOG.debug("Length of the record: {}", recordLength);

                 
                ignoreTrailingChars = fixedLengthRecord.ignoreTrailingChars();
                LOG.debug("Ignore trailing chars: {}", ignoreTrailingChars);

                ignoreMissingChars = fixedLengthRecord.ignoreMissingChars();
                LOG.debug("Enable ignore missing chars: {}", ignoreMissingChars);

                countGrapheme = fixedLengthRecord.countGrapheme();
                LOG.debug("Enable grapheme counting instead of codepoints: {}", countGrapheme);
            }
        }

        if (hasHeader && isHeader) {
            throw new java.lang.IllegalArgumentException(
                    "Record can not be configured with both 'isHeader=true' and 'hasHeader=true'");
        }

        if (hasFooter && isFooter) {
            throw new java.lang.IllegalArgumentException(
                    "Record can not be configured with both 'isFooter=true' and 'hasFooter=true'");
        }

        if ((isHeader || isFooter) && (skipHeader || skipFooter)) {
            throw new java.lang.IllegalArgumentException(
                    "skipHeader and/or skipFooter can not be configured on a record where 'isHeader=true' or 'isFooter=true'");
        }

    }

    private String eolDate(Row r) {
        try {
            if (r.eolDate != null) {
                SimpleDateFormat sdf = new SimpleDateFormat(YYYY_MM_DD);
                Date d = sdf.parse(r.eolDate);
                SimpleDateFormat sdf2 = new SimpleDateFormat(dateFormat, Locale.US);
                return sdf2.format(d);
            }
        } catch (Exception e) {
             
        }
        return r.eolDate != null ? r.eolDate : "";
    }

    private VolumeSnapshot messageToSnapshot(Message message) {
        VolumeSnapshot volume = message.getBody(VolumeSnapshot.class);
        if (volume == null) {
            Map headers = message.getHeaders();
            VolumeSnapshotBuilder builder = Builders.volumeSnapshot();

            final String name = message.getHeader(OpenstackConstants.NAME, String.class);
            StringHelper.notEmpty(name, "Name");
            builder.name(name);

            if (headers.containsKey(OpenstackConstants.DESCRIPTION)) {
                builder.description(message.getHeader(OpenstackConstants.DESCRIPTION, String.class));
            }

            if (headers.containsKey(CinderConstants.VOLUME_ID)) {
                builder.volume(message.getHeader(CinderConstants.VOLUME_ID, String.class));
            }

            if (headers.containsKey(CinderConstants.FORCE)) {
                builder.force(message.getHeader(CinderConstants.FORCE, Boolean.class));
            }

            volume = builder.build();
        }

        return volume;
    }

    public String dumpLatestMessageHistoryAsJSon() {
        List<BacklogTracerEventMessage> events = dumpLatestMessageHistory();

        JsonObject root = new JsonObject();
        JsonArray arr = new JsonArray();
        root.put("traces", arr);
        for (BacklogTracerEventMessage event : events) {
            arr.add(event.asJSon());
        }
        return Jsoner.prettyPrint(root.toJson());
    }

    public ASN1MessageIterator(Exchange exchange, InputStream inputStream) {
        this.exchange = exchange;
        if (inputStream instanceof ASN1InputStream) {
            this.asn1InputStream = (ASN1InputStream) inputStream;
        } else {
            this.asn1InputStream = new ASN1InputStream(inputStream);
        }
        this.parent = null;
    }

    private void setResult(Message message, boolean success, Object result, Object oldValue) {
        message.setHeader(CaffeineConstants.ACTION_SUCCEEDED, success);
        message.setHeader(CaffeineConstants.ACTION_HAS_RESULT, oldValue != null || result != null);

        if (oldValue != null) {
            message.setHeader(CaffeineConstants.OLD_VALUE, oldValue);
        }
        if (result != null) {
            message.setBody(result);
        }
    }

    public Integer doProcessWatchCall() throws Exception {
        List<Row> rows = new ArrayList<>();

        List<Long> pids = findPids(name);
        ProcessHandle.allProcesses()
                .filter(ph -> pids.contains(ph.pid()))
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                     
                    if (root != null) {
                        Row row = new Row();
                        JsonObject context = (JsonObject) root.get("context");
                        if (context == null) {
                            return;
                        }
                        row.name = context.getString("name");
                        if ("CamelJBang".equals(row.name)) {
                            row.name = ProcessHelper.extractName(root, ph);
                        }
                        row.pid = Long.toString(ph.pid());
                        row.uptime = extractSince(ph);
                        row.age = TimeUtils.printSince(row.uptime);

                        JsonObject jo = (JsonObject) root.get("rests");
                        if (jo != null) {
                            JsonArray arr = (JsonArray) jo.get("rests");
                            if (arr != null) {
                                for (int i = 0; i < arr.size(); i++) {
                                    row = row.copy();
                                    jo = (JsonObject) arr.get(i);
                                    row.url = jo.getString("url");
                                    row.method = jo.getString("method").toUpperCase(Locale.ROOT);
                                    row.consumes = jo.getString("consumes");
                                    row.produces = jo.getString("produces");
                                    row.description = jo.getString("description");
                                    row.contractFirst = jo.getBooleanOrDefault("contractFirst", false);
                                    rows.add(row);
                                }
                            }
                        }
                    }
                });

         
        rows.sort(this::sortRow);

        if (!rows.isEmpty()) {
            printer().println(AsciiTable.getTable(AsciiTable.NO_BORDERS, rows, Arrays.asList(
                    new Column().header("PID").headerAlign(HorizontalAlign.CENTER).with(r -> r.pid),
                    new Column().header("NAME").dataAlign(HorizontalAlign.LEFT).maxWidth(30, OverflowBehaviour.ELLIPSIS_RIGHT)
                            .with(r -> r.name),
                    new Column().header("URL").dataAlign(HorizontalAlign.LEFT).with(r -> r.url),
                    new Column().header("METHOD").dataAlign(HorizontalAlign.LEFT).with(r -> r.method),
                    new Column().header("FIRST").visible(verbose).dataAlign(HorizontalAlign.LEFT).with(this::getKind),
                    new Column().header("DESCRIPTION").visible(verbose).maxWidth(40, OverflowBehaviour.NEWLINE)
                            .dataAlign(HorizontalAlign.LEFT).with(r -> r.description),
                    new Column().header("CONTENT-TYPE").dataAlign(HorizontalAlign.LEFT).with(this::getContent))));
        }

        return 0;
    }

    public void setSecureRandomName(String randomName) {
        if (context != null && randomName != null) {
            SecureRandom random = context.getRegistry().lookupByNameAndType(randomName, SecureRandom.class);
            if (keystore != null) {
                setSecureRandom(random);
            }
        }
        if (randomName != null) {
            this.secureRandomName = randomName;
        }
    }

    public Expression createExpression(
            CamelContext camelContext, Annotation annotation,
            LanguageAnnotation languageAnnotation, Class<?> expressionReturnType) {

        Object[] params = new Object[3];
        Class<?> resultType = getResultType(annotation);
        if (resultType.equals(Object.class)) {
            resultType = expressionReturnType;
        }
        params[0] = resultType;
        if (annotation instanceof Joor) {
            Joor joorAnnotation = (Joor) annotation;
            params[1] = joorAnnotation.preCompile();
            params[2] = joorAnnotation.singleQuotes();
        }
        String expression = getExpressionFromAnnotation(annotation);
        return camelContext.resolveLanguage("joor").createExpression(expression, params);
    }

    protected Processor createBodyAndHeaderProcessor(final Object body, final String header, final Object headerValue) {
        return new Processor() {
            public void process(Exchange exchange) {
                Message in = exchange.getIn();
                in.setHeader(header, headerValue);
                in.setBody(body);
            }
        };
    }

    private void createGroup(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof GroupRepresentation) {
                Response response = keycloakClient.realm(realmName).groups().add((GroupRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            GroupRepresentation group = new GroupRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.GROUP_NAME))) {
                String groupName = exchange.getIn().getHeader(KeycloakConstants.GROUP_NAME, String.class);
                group.setName(groupName);
            } else {
                throw new IllegalArgumentException(MISSING_GROUP_NAME);
            }
            Response response = keycloakClient.realm(realmName).groups().add(group);
            Message message = getMessageForResponse(exchange);
            message.setBody(response);
        }
    }

    public ClosePullRequestProducer(GitHubEndpoint endpoint) throws Exception {
        super(endpoint);

        Registry registry = endpoint.getCamelContext().getRegistry();
        Object service = registry.lookupByName(GitHubConstants.GITHUB_PULL_REQUEST_SERVICE);
        if (service != null) {
            pullRequestService = (PullRequestService) service;
        } else {
            pullRequestService = new PullRequestService();
        }
        initService(pullRequestService);
    }

    protected int sortRow(Row o1, Row o2) {
         
        int answer = super.sortRow(o1, o2);
        if (answer == 0) {
            int negate = 1;
            if (sort.startsWith("-")) {
                negate = -1;
            }
             
            long m1 = o1.mean != null ? Long.parseLong(o1.mean) : 0;
            long m2 = o2.mean != null ? Long.parseLong(o2.mean) : 0;
            if (m1 < m2) {
                answer = negate;
            } else if (m1 > m2) {
                answer = -1 * negate;
            }
        }
        return answer;
    }

    public ResequenceDefinition reverse() {
        if (streamConfig != null) {
            throw new IllegalStateException("reverse() only supported for batch resequencer");
        }
         
        if (batchConfig == null) {
            batch();
        }
        batchConfig.setReverse(Boolean.toString(true));
        return this;
    }

    public DocFlavor forMimeTypeUSASCII(String flavor, String mimeType) {
        if (mimeType.equalsIgnoreCase("TEXT_HTML_US_ASCII")) {
            if (flavor.equalsIgnoreCase("DocFlavor.BYTE_ARRAY")) {
                d = DocFlavor.BYTE_ARRAY.TEXT_HTML_US_ASCII;
            } else if (flavor.equalsIgnoreCase("DocFlavor.INPUT_STREAM")) {
                d = DocFlavor.INPUT_STREAM.TEXT_HTML_US_ASCII;
            } else if (flavor.equalsIgnoreCase("DocFlavor.URL")) {
                d = DocFlavor.URL.TEXT_HTML_US_ASCII;
            }
        } else {
            if (flavor.equalsIgnoreCase("DocFlavor.BYTE_ARRAY")) {
                d = DocFlavor.BYTE_ARRAY.TEXT_PLAIN_US_ASCII;
            } else if (flavor.equalsIgnoreCase("DocFlavor.INPUT_STREAM")) {
                d = DocFlavor.INPUT_STREAM.TEXT_PLAIN_US_ASCII;
            } else if (flavor.equalsIgnoreCase("DocFlavor.URL")) {
                d = DocFlavor.URL.TEXT_PLAIN_US_ASCII;
            }
        }

        return d;
    }

    private String getPrompt(Exchange exchange) {
        String prompt = exchange.getIn().getHeader(GoogleVertexAIConstants.PROMPT, String.class);
        if (prompt == null) {
            prompt = exchange.getIn().getBody(String.class);
        }
        if (prompt == null) {
            throw new IllegalArgumentException("Prompt must be provided in body or header");
        }
        return prompt;
    }

    protected static List<String> getParameters(String path) {
        List<String> parameters = null;

        int startIndex = path.indexOf('{');
        while (startIndex != -1) {
            int endIndex = path.indexOf('}', startIndex);
            if (endIndex != -1) {
                if (parameters == null) {
                    parameters = new ArrayList<>();
                }
                parameters.add(path.substring(startIndex + 1, endIndex));
                startIndex = path.indexOf('{', endIndex);
            } else {
                 
                startIndex = -1;
            }
        }

        return parameters == null ? Collections.emptyList() : parameters;
    }

    private void describeCluster(EksClient eksClient, Exchange exchange) throws InvalidPayloadException {
        executeOperation(
                exchange,
                DescribeClusterRequest.class,
                eksClient::describeCluster,
                () -> {
                    String clusterName = getRequiredHeader(exchange, EKS2Constants.CLUSTER_NAME, String.class,
                            "Cluster name must be specified");
                    return eksClient.describeCluster(DescribeClusterRequest.builder().name(clusterName).build());
                },
                "Describe Cluster",
                (DescribeClusterResponse response, Message message) -> {
                    if (response.cluster() != null) {
                        message.setHeader(EKS2Constants.CLUSTER_ARN, response.cluster().arn());
                    }
                });
    }

    public RestDefinition id(String id) {
        if (getVerbs().isEmpty()) {
            super.id(id);
        } else {
             
            VerbDefinition verb = getVerbs().get(getVerbs().size() - 1);
            verb.id(id);
        }

        return this;
    }

    public static JsonObject asJsonObject(TransformerModel model) {
        JsonObject obj = new JsonObject();
        baseToJson(model, obj);
        artifactToJson(model, obj);
        obj.put("from", model.getFrom());
        obj.put("to", model.getTo());
        obj.entrySet().removeIf(e -> e.getValue() == null);
        JsonObject wrapper = new JsonObject();
        wrapper.put("transformer", obj);
        return wrapper;
    }

    private <REQ, RES> void executeOperation(
            Exchange exchange,
            Class<REQ> requestClass,
            Function<REQ, RES> pojoExecutor,
            Supplier<RES> headerExecutor,
            String operationName,
            BiConsumer<RES, Message> responseProcessor)
            throws InvalidPayloadException {

        RES result;
        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (requestClass.isInstance(payload)) {
                try {
                    result = pojoExecutor.apply(requestClass.cast(payload));
                } catch (AwsServiceException ase) {
                    LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                    throw ase;
                }
            } else {
                throw new IllegalArgumentException(
                        String.format("Expected body of type %s but was %s",
                                requestClass.getName(),
                                payload != null ? payload.getClass().getName() : "null"));
            }
        } else {
            try {
                result = headerExecutor.get();
            } catch (AwsServiceException ase) {
                LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                throw ase;
            }
        }
        Message message = getMessageForResponse(exchange);
        message.setBody(result);
        if (responseProcessor != null) {
            responseProcessor.accept(result, message);
        }
    }

    public static boolean updateResource(BuildContext buildContext, Path out, String data) {
        try {
            if (FileUtil.updateFile(out, data)) {
                refresh(buildContext, out);
                return true;
            }
        } catch (IOException e) {
            throw new IOError(e);
        }
        return false;
    }

        public KnativeServiceBuilder withMeta(String key, String value) {
            if (key == null || value == null) {
                return this;
            }
            if (this.metadata == null) {
                this.metadata = new HashMap<>();
            }
            this.metadata.put(key, value);
            return this;
        }

    protected void prepareDataFormatConfig(Map<String, Object> properties) {
        properties.put("xmlMapper", definition.getXmlMapper());
        properties.put("unmarshalType", or(definition.getUnmarshalType(), definition.getUnmarshalTypeName()));
        properties.put("jsonView", or(definition.getJsonView(), definition.getJsonViewTypeName()));
        properties.put("prettyPrint", definition.getPrettyPrint());
        properties.put("include", definition.getInclude());
        properties.put("allowJmsType", definition.getAllowJmsType());
        properties.put("collectionType", or(definition.getCollectionType(), definition.getCollectionTypeName()));
        properties.put("useList", definition.getUseList());
        properties.put("enableJaxbAnnotationModule", definition.getEnableJaxbAnnotationModule());
        properties.put("modulesClassNames", definition.getModuleClassNames());
        properties.put("moduleRefs", definition.getModuleRefs());
        properties.put("enableFeatures", definition.getEnableFeatures());
        properties.put("disableFeatures", definition.getDisableFeatures());
        properties.put("allowUnmarshallType", definition.getAllowUnmarshallType());
        properties.put("timezone", definition.getTimezone());
        properties.put("maxStringLength", definition.getMaxStringLength());
    }

    private void doInsert(Exchange exchange, SqlSession session) {
        Object result;
        Object in = getInput(exchange);
        if (in != null) {
            Iterator<?> iter;
            if (in instanceof Map) {
                 
                iter = Collections.singletonList(in).iterator();
            } else {
                iter = ObjectHelper.createIterator(in);
            }
            while (iter.hasNext()) {
                Object value = iter.next();
                LOG.trace("Inserting: {} using statement: {}", value, statement);
                result = session.insert(statement, value);
                doProcessResult(exchange, result, session);
            }
        } else {
            LOG.trace("Inserting using statement: {}", statement);
            result = session.insert(statement);
            doProcessResult(exchange, result, session);
        }
    }

    public String dumpAllTracedMessagesAsJSon() {
        List<BacklogTracerEventMessage> events = dumpAllTracedMessages();

        JsonObject root = new JsonObject();
        JsonArray arr = new JsonArray();
        root.put("traces", arr);
        for (BacklogTracerEventMessage event : events) {
            arr.add(event.asJSon());
        }
        return Jsoner.prettyPrint(root.toJson());
    }

    public KeyPair importKey(byte[] keyData, KeyFormat format, String algorithm) throws Exception {
         
        try {
            PrivateKey privateKey = KeyFormatConverter.importPrivateKey(keyData, format, getAlgorithmName(algorithm));
            LOG.warn("Importing private key only - public key derivation may be needed");
            return new KeyPair(null, privateKey);
        } catch (Exception e) {
             
            PublicKey publicKey = KeyFormatConverter.importPublicKey(keyData, format, getAlgorithmName(algorithm));
            return new KeyPair(publicKey, null);
        }
    }

    protected JsonObject doCallJson(Map<String, Object> options) {
        JsonObject root = new JsonObject();
        if (propertiesFunction != null) {
            root.put("region", propertiesFunction.getRegion());
            if (propertiesFunction.isDefaultCredentialsProvider()) {
                root.put("login", "DefaultCredentialsProvider");
            } else if (propertiesFunction.isProfleCredentialsProvider()) {
                root.put("login", "ProfileCredentialsProvider");
            } else {
                root.put("login", "Access and Secret Keys");
            }
            AwsVaultConfiguration aws = getCamelContext().getVaultConfiguration().getAwsVaultConfiguration();
            if (aws != null) {
                root.put("refreshEnabled", aws.isRefreshEnabled());
                root.put("refreshPeriod", aws.getRefreshPeriod());
            }
            if (secretsRefreshTask != null) {
                Instant last = secretsRefreshTask.getLastCheckTime();
                if (last != null) {
                    long timestamp = last.toEpochMilli();
                    root.put("lastCheckTimestamp", timestamp);
                    root.put("lastCheckAge", TimeUtils.printSince(timestamp));
                }
                last = secretsRefreshTask.getLastReloadTime();
                if (last != null) {
                    long timestamp = last.toEpochMilli();
                    root.put("lastReloadTimestamp", timestamp);
                    root.put("lastReloadAge", TimeUtils.printSince(timestamp));
                }
            }
            JsonArray arr = new JsonArray();
            root.put("secrets", arr);

            List<String> sorted = new ArrayList<>(propertiesFunction.getSecrets());
            Collections.sort(sorted);

            for (String sec : sorted) {
                JsonObject jo = new JsonObject();
                jo.put("name", sec);
                Instant last = secretsRefreshTask != null ? secretsRefreshTask.getUpdates().get(sec) : null;
                if (last != null) {
                    long timestamp = last.toEpochMilli();
                    jo.put("timestamp", timestamp);
                    jo.put("age", TimeUtils.printSince(timestamp));
                }
                arr.add(jo);
            }
        }
        return root;
    }

    private boolean isValidGrep(String line) {
        if (grep == null) {
            return true;
        }
        for (String g : grep) {
            boolean m = Pattern.compile("(?i)" + g).matcher(line).find();
            if (m) {
                return true;
            }
        }
        return false;
    }

    private String doCreateCode(CamelContext camelContext, String expression) throws SimpleParserException {
        ObjectHelper.notNull(left, "left node", this);
        ObjectHelper.notNull(right, "right node", this);

        final String leftExp = left.createCode(camelContext, expression);
        final String rightExp = right.createCode(camelContext, expression);

        if (operator == LogicalOperatorType.AND) {
            return leftExp + " && " + rightExp;
        } else if (operator == LogicalOperatorType.OR) {
            return leftExp + " || " + rightExp;
        }

        throw new SimpleParserException("Unknown logical operator " + operator, token.getIndex());
    }

    private static DataLakeServiceClient createDataLakeServiceClientWithSas(
            final DataLakeConfiguration configuration) {
        AzureSasCredential sasCredential = configuration.getSasCredential();
        if (sasCredential == null) {
            LOG.trace("Using SAS signature to instantiate service client");
            sasCredential = new AzureSasCredential(configuration.getSasSignature());
        } else {
            LOG.trace("Using configured SAS instance to instantiate service client");
        }

        return new DataLakeServiceClientBuilder()
                .credential(sasCredential)
                .endpoint(buildAzureUri(configuration))
                .buildClient();
    }

    private ClientConfigurations initializeConfigurations(ImageRecognitionEndpoint endpoint) {
        ClientConfigurations clientConfigurations = new ClientConfigurations();

        clientConfigurations.setAccessKey(getAccessKey(endpoint));
        clientConfigurations.setSecretKey(getSecretKey(endpoint));
        clientConfigurations.setProjectId(getProjectId(endpoint));
        clientConfigurations.setEndpoint(getEndpoint(endpoint));

        clientConfigurations.setIgnoreSslVerification(endpoint.isIgnoreSslVerification());
        if (clientConfigurations.isIgnoreSslVerification()) {
            LOG.warn("SSL verification is ignored. This is unsafe in production environment");
        }
        if (!StringUtils.isEmpty(endpoint.getProxyHost())) {
            clientConfigurations.setProxyHost(endpoint.getProxyHost());
            clientConfigurations.setProxyPort(endpoint.getProxyPort());
            clientConfigurations.setProxyUser(endpoint.getProxyUser());
            clientConfigurations.setProxyPassword(endpoint.getProxyPassword());
        }
        return clientConfigurations;
    }

    private FTPFile[] getFtpFiles(GenericFileOperations<FTPFile> operations, GenericFile<FTPFile> file) {
        FTPFile[] files;
        if (fastExistsCheck) {
             
             
             
            files = getFtpFilesFast(operations, file);
        } else {
            files = getFtpFilesByFilter(operations, file);
        }
        return files;
    }

    private ScrollResponse<TDocument> scrollSearch() {
        ScrollResponse<TDocument> scrollResponse;
        try {
            ScrollRequest searchScrollRequest = new ScrollRequest.Builder()
                    .scroll(Time.of(b -> b.time(String.format("%sms", scrollKeepAliveMs))))
                    .scrollId(scrollId)
                    .build();

            scrollResponse = esClient.scroll(searchScrollRequest, documentClass);
            requestCount++;
        } catch (IOException e) {
            throw new IllegalStateException(e);
        }
        return scrollResponse;
    }

    List<Long> findPids(String name) {
        List<Long> pids = new ArrayList<>();

         
        if (name.matches("\\d+")) {
            return List.of(Long.parseLong(name));
        } else {
            if (name.endsWith("!")) {
                 
                name = name.substring(0, name.length() - 1);
            } else if (!name.endsWith("*")) {
                 
                name = name + "*";
            }
        }

        final long cur = ProcessHandle.current().pid();
        final String pattern = name;
        ProcessHandle.allProcesses()
                .filter(ph -> ph.pid() != cur)
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                     
                    if (root != null) {
                        String pName = ProcessHelper.extractName(root, ph);
                         
                        pName = FileUtil.onlyName(pName);
                        if (pName != null && !pName.isEmpty() && PatternHelper.matchPattern(pName, pattern)) {
                            pids.add(ph.pid());
                        } else {
                             
                            JsonObject context = (JsonObject) root.get("context");
                            if (context != null) {
                                pName = context.getString("name");
                                if ("CamelJBang".equals(pName)) {
                                    pName = null;
                                }
                                if (pName != null && !pName.isEmpty() && PatternHelper.matchPattern(pName, pattern)) {
                                    pids.add(ph.pid());
                                }
                            }
                        }
                    }
                });

        return pids;
    }

    public boolean acquireExclusiveReadLock(
            GenericFileOperations<FileIdBothDirectoryInformation> operations, GenericFile<FileIdBothDirectoryInformation> file,
            Exchange exchange) {

        LOG.trace("Waiting for exclusive read lock to file: {}", file);

        BlockingTask task = Tasks.foregroundTask()
                .withBudget(Budgets.iterationTimeBudget()
                        .withMaxDuration(Duration.ofMillis(timeout))
                        .withInterval(Duration.ofMillis(checkInterval))
                        .build())
                .withName("smb-acquire-exclusive-read-lock")
                .build();

        SmbExclusiveReadLockCheck exclusiveReadLockCheck = new SmbExclusiveReadLockCheck(minAge, minLength);

        if (!task.run(exchange.getContext(), () -> exclusiveReadLockCheck.tryAcquireExclusiveReadLock(operations, file))) {
            CamelLogger.log(LOG, readLockLoggingLevel,
                    "Cannot acquire read lock within " + timeout + " millis. Will skip the file: " + file);

            return false;
        }
        return true;
    }

        protected void decodeStructuredContent(Exchange exchange, Map<String, Object> content) {
            final CloudEvent ce = cloudEvent();
            final Message message = exchange.getIn();

             
            ifNotEmpty(content.remove("data"), message::setBody);

            ifNotEmpty(content.remove(ce.mandatoryAttribute(CloudEvent.CAMEL_CLOUD_EVENT_DATA_CONTENT_TYPE).json()), val -> {
                message.setHeader(Exchange.CONTENT_TYPE, val);
            });

            for (CloudEvent.Attribute attribute : ce.attributes()) {
                ifNotEmpty(content.remove(attribute.json()), val -> {
                    message.setHeader(attribute.id(), val);
                });
            }

             
             
             
            content.forEach((key, val) -> {
                message.setHeader(key.toLowerCase(Locale.US), val);
            });
        }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.lang.String.class, org.snmp4j.PDU.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.snmp.SnmpConverters.toString((org.snmp4j.PDU) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.component.snmp.OIDList.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.snmp.SnmpConverters.toOIDList((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    public void process(Exchange exchange) {
        var context = exchange.getContext();
        var msg = exchange.getMessage();

        logRequestHeaders(procName, msg);

         
         
        var oauth = findOAuth(context).orElseGet(() -> {
            var factory = OAuthFactory.lookupFactory(context);
            return factory.createOAuth();
        });

         
         
        var session = oauth.getOrCreateSession(exchange);

         
         
        if (session.getUserProfile().isPresent()) {
            var userProfile = session.removeUserProfile().orElseThrow();
            try {
                userProfile = authenticateExistingUserProfile(oauth, userProfile);
                session.putUserProfile(userProfile);
                return;
            } catch (OAuthException ex) {
                log.error("Failed to authenticate: {}", userProfile.subject(), ex);
            }
        }

         
         
        var clientId = getRequiredProperty(exchange.getContext(), CAMEL_OAUTH_CLIENT_ID);
        var clientSecret = getRequiredProperty(exchange.getContext(), CAMEL_OAUTH_CLIENT_SECRET);

        var userProfile = oauth.authenticate(new ClientCredentials()
                .setClientSecret(clientSecret)
                .setClientId(clientId));

        session.putUserProfile(userProfile);
        log.info("Authenticated {}", userProfile.subject());
        userProfile.logDetails();

         
         
        var accessToken = userProfile.accessToken().orElseThrow(() -> new OAuthException("No access_token"));
        msg.setHeader("Authorization", "Bearer " + accessToken);
    }

    protected static Stream<String> combine(String... items) {
        Set<String> answer = new TreeSet<>();

        for (String item : items) {
            if (item == null) {
                continue;
            }

            String[] elements = item.split(",");
            answer.addAll(Arrays.asList(elements));
        }

        return answer.stream();
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulHealthProducer target = (org.apache.camel.component.consul.endpoint.ConsulHealthProducer) obj;
        switch (key) {
        case "checks":
        case "CHECKS": target.checks(exchange.getMessage()); return null;
        case "node_checks":
        case "NODE_CHECKS": target.nodeChecks(exchange.getMessage()); return null;
        case "service_checks":
        case "SERVICE_CHECKS": target.serviceChecks(exchange.getMessage()); return null;
        case "service_instances":
        case "SERVICE_INSTANCES": target.serviceInstances(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public void interceptProperties(Map<String, Object> properties) {
        Map<String, String> endpointHttpHeaders = (Map<String, String>) properties.get(ENDPOINT_HTTP_HEADERS_PROPERTY);

         
        properties.put(EDM_PROPERTY, apiProxy.getEdm(endpointHttpHeaders));

         
        properties.put(FILTER_ALREADY_SEEN, configuration.isFilterAlreadySeen());

         
        final String keyPredicate = (String) properties.get(KEY_PREDICATE_PROPERTY);
        if (keyPredicate != null) {

             
            properties.compute(RESOURCE_PATH_PROPERTY, (key, resourcePath) -> {
                if (resourcePath == null) {
                    throw new IllegalArgumentException(
                            "Resource path must be provided in endpoint URI, or URI parameter '" + RESOURCE_PATH_PROPERTY
                                                       + "', or exchange header '"
                                                       + Olingo4Constants.PROPERTY_PREFIX + RESOURCE_PATH_PROPERTY + "'");
                }

                 
                return resourcePath + "(" + keyPredicate + ")";
            });
        }

         
        parseQueryParams(properties);
    }

    private DaprOperationResponse waitForInstanceStart(Exchange exchange, DaprWorkflowClient client) {
        String instanceId = configurationOptionsProxy.getWorkflowInstanceId(exchange);
        Duration timeout = configurationOptionsProxy.getTimeout(exchange);
        boolean getWorkflowIO = configurationOptionsProxy.getWorkflowIO(exchange);

        try {
            WorkflowInstanceStatus response = client.waitForInstanceStart(instanceId, timeout, getWorkflowIO);
            return DaprOperationResponse.createFromWorkflowStatus(response);
        } catch (TimeoutException exception) {
            throw new RuntimeCamelException(
                    "Workflow instance " + instanceId + " could not be started in " + timeout, exception);
        }
    }

    public XMLSecurityDataFormat() {
        this.xmlCipherAlgorithm = XMLCipher.AES_256_GCM;
        this.secureTag = "";
        this.secureTagContents = true;

         
        boolean wasSet = false;
        try {
             
            String lineBreakPropName = "org.apache.xml.security.ignoreLineBreaks";
            if (System.getProperty(lineBreakPropName) == null) {
                System.setProperty(lineBreakPropName, "true");
                wasSet = false;
            } else {
                wasSet = true;
            }
        } catch (Exception t) {
             
        }

        org.apache.xml.security.Init.init();

        if (!wasSet) {
            try {
                Field f = XMLUtils.class.getDeclaredField("ignoreLineBreaks");
                f.setAccessible(true);
                f.set(null, Boolean.TRUE);
            } catch (Exception t) {
                 
            }
        }
    }

    public Float getFloatOrDefault(final String key, final float defaultValue) {
        Object returnable;
        if (this.containsKey(key)) {
            returnable = this.get(key);
        } else {
            return defaultValue;
        }
        if (returnable == null) {
            return null;
        }
        if (returnable instanceof String) {
             
            returnable = new BigDecimal((String) returnable);
        }
        return ((Number) returnable).floatValue();
    }

    public static Expression mandatoryBodyExpression(final String name) {
        return new ExpressionAdapter() {
            private ClassResolver classResolver;
            private Expression exp;

            @Override
            public Object evaluate(Exchange exchange) {
                String text = exp.evaluate(exchange, String.class);
                Class<?> type;
                try {
                    type = classResolver.resolveMandatoryClass(text);
                } catch (ClassNotFoundException e) {
                    throw CamelExecutionException.wrapCamelExecutionException(exchange, e);
                }
                try {
                    return exchange.getIn().getMandatoryBody(type);
                } catch (InvalidPayloadException e) {
                    throw CamelExecutionException.wrapCamelExecutionException(exchange, e);
                }
            }

            @Override
            public void init(CamelContext context) {
                classResolver = context.getClassResolver();
                exp = ExpressionBuilder.simpleExpression(name);
                exp.init(context);
            }

            @Override
            public String toString() {
                return "mandatoryBodyAs[" + name + "]";
            }
        };
    }

    public void transform(Message message, DataType fromType, DataType toType) {
        final Map<String, Object> headers = message.getHeaders();

        CloudEvent cloudEvent = CloudEvents.v1_0;
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_ID, message.getExchange().getExchangeId());
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_VERSION, cloudEvent.version());
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TYPE, "org.apache.camel.event.google.calendar.stream.consume");

        if (message.getHeaders().containsKey(GoogleCalendarStreamConstants.EVENT_ID)) {
            headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SOURCE,
                    "google.calendar.stream." + message.getHeader(GoogleCalendarStreamConstants.EVENT_ID, String.class));
        }

        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SUBJECT,
                message.getBody(Event.class).getEventType());
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TIME, cloudEvent.getEventTime(message.getExchange()));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_CONTENT_TYPE, CloudEvent.APPLICATION_OCTET_STREAM_MIME_TYPE);
    }

    public ResequenceDefinition size(int batchSize) {
        if (streamConfig != null) {
            throw new IllegalStateException("size() only supported for batch resequencer");
        }
         
        if (batchConfig == null) {
            batch();
        }
        batchConfig.setBatchSize(Integer.toString(batchSize));
        return this;
    }

    public void configureAuthentication(
            AuthenticationConfig authenticationConfig,
            HttpServerConfigurationProperties properties) {

        String path
                = isNotEmpty(properties.getAuthenticationPath()) ? properties.getAuthenticationPath() : properties.getPath();
         
        if ("/".equals(path)) {
            path = "/*";
        }
        String realm = properties.getAuthenticationRealm() != null ? properties.getAuthenticationRealm() : null;

        AuthenticationConfigEntry entry = new AuthenticationConfigEntry();
        entry.setPath(path);
        entry.setAuthenticationHandlerFactory(new AuthenticationHandlerFactory() {
            @Override
            public <T extends AuthenticationProvider> AuthenticationHandler createAuthenticationHandler(
                    T authenticationProvider) {
                JWTAuth authProvider = (JWTAuth) authenticationProvider;
                return JWTAuthHandler.create(authProvider, realm);
            }
        });
        entry.setAuthenticationProviderFactory(vertx -> JWTAuth.create(
                vertx,
                new JWTAuthOptions(
                        new JsonObject().put("keyStore", new JsonObject()
                                .put("type", properties.getJwtKeystoreType())
                                .put("path", properties.getJwtKeystorePath())
                                .put("password", properties.getJwtKeystorePassword())))));

        authenticationConfig.getEntries().add(entry);
        authenticationConfig.setEnabled(true);
    }

        public CamelContext getOrLookupCamelContext() {
            CamelContext answer = CamelBeanPostProcessor.this.camelContext;
            if (answer == null) {
                if (camelId != null) {
                    LOG.trace("Looking up CamelContext by id: {} from Spring ApplicationContext: {}", camelId,
                            applicationContext);
                    answer = applicationContext.getBean(camelId, CamelContext.class);
                } else {
                     
                    LOG.trace("Looking up CamelContext by type from Spring ApplicationContext: {}", applicationContext);
                    Map<String, CamelContext> contexts = applicationContext.getBeansOfType(CamelContext.class);
                    if (contexts.size() == 1) {
                        answer = contexts.values().iterator().next();
                    }
                }
                if (answer != null) {
                     
                    CamelBeanPostProcessor.this.camelContext = answer;
                }
            }
            return answer;
        }

    private SSLContext createSSLContext(CamelContext camelContext, NettyServerBootstrapConfiguration configuration)
            throws Exception {
        if (!configuration.isSsl()) {
            return null;
        }

        SSLContext answer;

         
        if (configuration.getSslContextParameters() != null) {
            answer = configuration.getSslContextParameters().createSSLContext(camelContext);
        } else {
            SSLEngineFactory sslEngineFactory = new SSLEngineFactory();
            answer = sslEngineFactory.createSSLContext(camelContext,
                    configuration.getKeyStoreFormat(),
                    configuration.getSecurityProvider(),
                    configuration.getKeyStoreResource(),
                    configuration.getTrustStoreResource(),
                    configuration.getPassphrase().toCharArray());
        }

        return answer;
    }

    protected static JsonObject getJsonObject(Path outputFile, long timeout) {
        StopWatch watch = new StopWatch();
        while (watch.taken() < 5000) {
            File f = outputFile.toFile();
            try {
                 
                Thread.sleep(100);

                if (Files.exists(outputFile) && f.length() > 0) {
                    String text = Files.readString(outputFile);
                    return (JsonObject) Jsoner.deserialize(text);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } catch (Exception e) {
                 
            }
        }
        return null;
    }

        public void parse(InputSource input) throws IOException, SAXException {
            lock.lock();
            try {
                checkValid();
                try {
                    xmlReader.parse(input);
                } finally {
                    release();
                }
            } finally {
                lock.unlock();
            }
        }

    private void createTarEntries(TarArchiveOutputStream tos, String filepath, Long filelength) throws IOException {
        Iterator<Path> elements = Paths.get(filepath).iterator();
        StringBuilder sb = new StringBuilder(256);

        while (elements.hasNext()) {
            Path path = elements.next();
            String element = path.toString();
            Long length = filelength;

             
             
            if (elements.hasNext()) {
                element += "/";
                length = 0L;
            }

             
            TarArchiveEntry entry = new TarArchiveEntry(sb + element);
            entry.setSize(length);
            tos.putArchiveEntry(entry);

            sb.append(element);
        }
    }

    private static void extractAttributes(Node xmlNode, RestVerbDetails detail) {
        NamedNodeMap map = xmlNode.getAttributes();
        detail.setPath(extractAttribute(map, "path"));
        detail.setConsumes(extractAttribute(map, "consumes"));
        detail.setProduces(extractAttribute(map, "produces"));
        detail.setApiDocs(extractAttribute(map, "apiDocs"));
        detail.setBindingMode(extractAttribute(map, "bindingMode"));
        detail.setClientRequestValidation(extractAttribute(map, "clientRequestValidation"));
        detail.setClientResponseValidation(extractAttribute(map, "clientResponseValidation"));
        detail.setSkipBindingOnErrorCode(extractAttribute(map, "skipBindingOnErrorCode"));
        detail.setType(extractAttribute(map, "type"));
        detail.setOutType(extractAttribute(map, "outType"));
    }

    private void doCreateOrUpdateService(
            Exchange exchange, String operationName, Function<Resource<Service>, Service> operation) {
        String serviceName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_SERVICE_NAME, String.class);
        String namespaceName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        ServiceSpec serviceSpec = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_SERVICE_SPEC, ServiceSpec.class);
        if (ObjectHelper.isEmpty(serviceName)) {
            LOG.error("{} a specific service require specify a service name", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific service require specify a service name", operationName));
        }
        if (ObjectHelper.isEmpty(namespaceName)) {
            LOG.error("{} a specific service require specify a namespace name", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific service require specify a namespace name", operationName));
        }
        if (ObjectHelper.isEmpty(serviceSpec)) {
            LOG.error("{} a specific service require specify a service spec bean", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific service require specify a service spec bean", operationName));
        }
        Map<String, String> labels = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_SERVICE_LABELS, Map.class);
        Service serviceCreating = new ServiceBuilder().withNewMetadata().withName(serviceName).withLabels(labels).endMetadata()
                .withSpec(serviceSpec).build();
        Service service
                = operation.apply(
                        getEndpoint().getKubernetesClient().services().inNamespace(namespaceName).resource(serviceCreating));

        prepareOutboundMessage(exchange, service);
    }

    private Olingo4AppWrapper createOlingo4App(Olingo4Configuration configuration) {

        Object clientBuilder = configuration.getHttpAsyncClientBuilder();
        if (clientBuilder == null) {
            HttpAsyncClientBuilder asyncClientBuilder = HttpAsyncClientBuilder.create();

             
            final RequestConfig.Builder requestConfigBuilder = RequestConfig.custom();
            requestConfigBuilder.setConnectTimeout(configuration.getConnectTimeout());
            requestConfigBuilder.setSocketTimeout(configuration.getSocketTimeout());

            final HttpHost proxy = configuration.getProxy();
            if (proxy != null) {
                requestConfigBuilder.setProxy(proxy);
            }

             
            asyncClientBuilder.setDefaultRequestConfig(requestConfigBuilder.build());

            SSLContextParameters sslContextParameters = configuration.getSslContextParameters();
            if (sslContextParameters == null) {
                 
                sslContextParameters = retrieveGlobalSslContextParameters();
            }
            if (sslContextParameters == null) {
                 
                sslContextParameters = new SSLContextParameters();
            }
            try {
                asyncClientBuilder.setSSLContext(sslContextParameters.createSSLContext(getCamelContext()));
            } catch (IOException | GeneralSecurityException e) {
                throw RuntimeCamelException.wrapRuntimeCamelException(e);
            }

            clientBuilder = asyncClientBuilder;
        }

        Olingo4AppImpl olingo4App;
        if (clientBuilder == null || clientBuilder instanceof HttpAsyncClientBuilder) {
            olingo4App = new Olingo4AppImpl(configuration.getServiceUri(), (HttpAsyncClientBuilder) clientBuilder);
        } else {
            olingo4App = new Olingo4AppImpl(configuration.getServiceUri(), (HttpClientBuilder) clientBuilder);
        }
        apiProxy = new Olingo4AppWrapper(olingo4App);
        apiProxy.getOlingo4App().setContentType(configuration.getContentType());
        apiProxy.getOlingo4App().setHttpHeaders(configuration.getHttpHeaders());

        return apiProxy;
    }

        public String toString() {
            if (!onCompleteOnly && !onFailureOnly) {
                return "onCompleteOrFailure";
            } else if (onCompleteOnly) {
                return "onCompleteOnly";
            } else {
                return "onFailureOnly";
            }
        }

    protected void autoConfigure(String key) {
        var config = new org.apache.camel.util.OrderedLocationProperties();
        config.putAll("camel-main", camelContext.getPropertiesComponent().loadProperties());

         
        InputStream is = getClass().getResourceAsStream("/auto-configure/" + key + ".java");
        if (is != null) {
            try {
                 
                DependencyDownloader downloader = camelContext.hasService(DependencyDownloader.class);
                 
                downloader.downloadHiddenDependency("org.apache.camel", "camel-joor", camelContext.getVersion());
                 
                String script = IOHelper.loadText(is);
                Language lan = camelContext.resolveLanguage("java");
                Expression exp = lan.createExpression(script);
                Object out = exp.evaluate(new DefaultExchange(camelContext), Object.class);
                if (ObjectHelper.isNotEmpty(out)) {
                    LOG.info("{}", out);
                }
            } catch (Exception e) {
                throw RuntimeCamelException.wrapRuntimeException(e);
            } finally {
                IOHelper.close(is);
            }
        }
    }

        public void calculateAndSetMaxConcurrentRequestsExpression(final Exchange exchange) throws Exception {
            lock.lock();
            try {
                Integer newThrottle = getMaximumRequestsExpression().evaluate(exchange, Integer.class);

                if (newThrottle != null && newThrottle < 0) {
                    throw new IllegalStateException(
                            "The maximumConcurrentRequests must be a positive number, was: " + newThrottle);
                }

                if (newThrottle == null && throttleRate == 0) {
                    throw new RuntimeExchangeException(
                            "The maxConcurrentRequestsExpression was evaluated as null: " + getMaximumRequestsExpression(),
                            exchange);
                }

                if (newThrottle != null) {
                    if (newThrottle != throttleRate) {
                         
                        if (throttleRate > newThrottle) {
                            int delta = throttleRate - newThrottle;

                             
                            semaphore.reducePermits(delta);
                            if (LOG.isDebugEnabled()) {
                                LOG.debug("Throttle rate decreased from {} to {}, triggered by ExchangeId: {}", throttleRate,
                                        newThrottle, exchange.getExchangeId());
                            }

                             
                        } else if (newThrottle > throttleRate) {
                            int delta = newThrottle - throttleRate;
                            semaphore.increasePermits(delta);
                            if (throttleRate == 0) {
                                if (LOG.isDebugEnabled()) {
                                    LOG.debug("Initial throttle rate set to {}, triggered by ExchangeId: {}", newThrottle,
                                            exchange.getExchangeId());
                                }
                            } else {
                                if (LOG.isDebugEnabled()) {
                                    LOG.debug("Throttle rate increase from {} to {}, triggered by ExchangeId: {}", throttleRate,
                                            newThrottle, exchange.getExchangeId());
                                }
                            }
                        }
                        throttleRate = newThrottle;
                    }
                }
            } finally {
                lock.unlock();
            }
        }

    protected void ensureNamespacesCapacity(int size) {
        final int namespaceSize = namespacePrefix != null ? namespacePrefix.length : 0;
        if (size >= namespaceSize) {
            final int newSize = size > 7 ? 2 * size : 8;  
            if (TRACE_SIZING) {
                System.err.println("TRACE_SIZING namespaceSize " + namespaceSize + " ==> " + newSize);
            }
            final String[] newNamespacePrefix = new String[newSize];
            final String[] newNamespaceUri = new String[newSize];
            if (namespacePrefix != null) {
                System.arraycopy(namespacePrefix, 0, newNamespacePrefix, 0, namespaceEnd);
                System.arraycopy(namespaceUri, 0, newNamespaceUri, 0, namespaceEnd);
            }
            namespacePrefix = newNamespacePrefix;
            namespaceUri = newNamespaceUri;

            if (!allStringsInterned) {
                final int[] newNamespacePrefixHash = new int[newSize];
                if (namespacePrefixHash != null) {
                    System.arraycopy(namespacePrefixHash, 0, newNamespacePrefixHash, 0, namespaceEnd);
                }
                namespacePrefixHash = newNamespacePrefixHash;
            }
             
             
        }
    }

    public static Path getKubernetesManifestPath(String clusterType, Path workingDir, String extension) {
        String manifestFile;
        if (ClusterType.KIND.isEqualTo(clusterType) || ClusterType.MINIKUBE.isEqualTo(clusterType)) {
            manifestFile = "kubernetes";
        } else {
            manifestFile = Optional.ofNullable(clusterType).map(String::toLowerCase).orElse("kubernetes");
        }
        return workingDir.resolve("%s.%s".formatted(manifestFile, extension));
    }

    protected JsonObject doCallJson(Map<String, Object> options) {
        JsonObject root = new JsonObject();
        if (propertiesFunction != null) {
            root.put("login", "Client Id/Client Secret");
            AzureVaultConfiguration azure = getCamelContext().getVaultConfiguration().getAzureVaultConfiguration();
            if (azure != null) {
                root.put("refreshEnabled", azure.isRefreshEnabled());
                root.put("refreshPeriod", azure.getRefreshPeriod());
            }
            if (secretsRefreshTask != null) {
                Instant last = secretsRefreshTask.getLastCheckTime();
                if (last != null) {
                    long timestamp = last.toEpochMilli();
                    root.put("lastCheckTimestamp", timestamp);
                    root.put("lastCheckAge", TimeUtils.printSince(timestamp));
                }
                last = secretsRefreshTask.getLastReloadTime();
                if (last != null) {
                    long timestamp = last.toEpochMilli();
                    root.put("lastReloadTimestamp", timestamp);
                    root.put("lastReloadAge", TimeUtils.printSince(timestamp));
                }
            }
            JsonArray arr = new JsonArray();
            root.put("secrets", arr);

            List<String> sorted = new ArrayList<>(propertiesFunction.getSecrets());
            Collections.sort(sorted);

            for (String sec : sorted) {
                JsonObject jo = new JsonObject();
                jo.put("name", sec);
                Instant last = secretsRefreshTask != null ? secretsRefreshTask.getUpdates().get(sec) : null;
                if (last != null) {
                    long timestamp = last.toEpochMilli();
                    jo.put("timestamp", timestamp);
                    jo.put("age", TimeUtils.printSince(timestamp));
                }
                arr.add(jo);
            }
        }
        return root;
    }

    private void includeProcessorsJson(ManagedRouteMBean mrb, JsonArray arr, String filter, int max) {
        ManagedCamelContext mcc = getCamelContext().getCamelContextExtension().getContextPlugin(ManagedCamelContext.class);

        Collection<String> ids;
        try {
            ids = mrb.processorIds();
        } catch (Exception e) {
            return;
        }

         
        List<ManagedProcessorMBean> mps = new ArrayList<>();
        for (String id : ids) {
            ManagedProcessorMBean mp = mcc.getManagedProcessor(id);
            if (mp != null && accept(mp, filter)) {
                mps.add(mp);
            }
        }

         
        mps.sort(Comparator.comparingInt(ManagedProcessorMBean::getIndex));

         
        includeProcessorsJSon(getCamelContext(), arr, max, mps);
    }

    public static void findJavaFiles(File dir, Set<File> javaFiles) {
        File[] files = dir.isDirectory() ? dir.listFiles() : null;
        if (files != null) {
            for (File file : files) {
                if (file.getName().endsWith(".java")) {
                    javaFiles.add(file);
                } else if (file.isDirectory()) {
                    findJavaFiles(file, javaFiles);
                }
            }
        }
    }

    public static void toResult(Source source, Result result) throws TransformerException {
        if (source != null) {
            XMLConverterHelper xml = new XMLConverterHelper();
            TransformerFactory factory = xml.getTransformerFactory();
            Transformer transformer = factory.newTransformer();
            if (transformer == null) {
                throw new TransformerException("Could not create a transformer - JAXP is misconfigured!");
            } else {
                Properties outputProperties = new Properties();
                outputProperties.put("encoding", defaultCharset);
                outputProperties.put("omit-xml-declaration", "yes");

                transformer.setOutputProperties(outputProperties);
                transformer.transform(source, result);
            }
        }
    }

    public boolean checkAfterSendProperties(Exchange exchange, Socket socket, Logger log) {
        final String logMessageFormat = "Exchange property {} = {} - {} connection";
        boolean answer = true;

        final boolean resetAfterSend
                = exchange.getProperty(MllpConstants.MLLP_RESET_CONNECTION_AFTER_SEND, false, boolean.class);
        if (resetAfterSend) {
            log.warn(logMessageFormat, MllpConstants.MLLP_RESET_CONNECTION_AFTER_SEND,
                    exchange.getProperty(MllpConstants.MLLP_RESET_CONNECTION_AFTER_SEND), "resetting");
            doConnectionClose(socket, true, log);
            answer = false;
        } else {
            final boolean closeAfterSend
                    = exchange.getProperty(MllpConstants.MLLP_CLOSE_CONNECTION_AFTER_SEND, false, boolean.class);
            if (closeAfterSend) {
                log.warn(logMessageFormat, MllpConstants.MLLP_CLOSE_CONNECTION_AFTER_SEND,
                        exchange.getProperty(MllpConstants.MLLP_CLOSE_CONNECTION_AFTER_SEND), "closing");
                doConnectionClose(socket, false, log);
                answer = false;
            }
        }

        return answer;
    }

    public void remove(final CamelContext camelContext, final String correlationId, final Exchange exchange) {
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
            protected void doInTransactionWithoutResult(TransactionStatus status) {
                final String confirmKey = exchange.getExchangeId();
                final long version = exchange.getProperty(VERSION_PROPERTY, Long.class);
                try {
                    LOG.debug("Removing key {}", correlationId);
                    String table = getRepositoryName();
                    verifyTableName(table);
                    jdbcTemplate.update("DELETE FROM " + table + " WHERE " + ID + " = ? AND " + VERSION + " = ?",  
                            correlationId, version);

                    insert(camelContext, confirmKey, exchange, getRepositoryNameCompleted(), version, true);

                } catch (Exception e) {
                    throw new RuntimeException(
                            "Error removing key " + correlationId + " from repository " + getRepositoryName(), e);
                }
            }
        });
    }

    private void delayOrScheduleLockRelease(Runnable r) throws InterruptedException {
        if (readLockIdempotentReleaseDelay > 0 && readLockIdempotentReleaseExecutorService != null) {
            LOG.debug("Scheduling read lock release task to run asynchronous delayed after {} millis",
                    readLockIdempotentReleaseDelay);
            readLockIdempotentReleaseExecutorService.schedule(r, readLockIdempotentReleaseDelay, TimeUnit.MILLISECONDS);
        } else if (readLockIdempotentReleaseDelay > 0) {
            LOG.debug("Delaying read lock release task {} millis", readLockIdempotentReleaseDelay);
            Thread.sleep(readLockIdempotentReleaseDelay);
            r.run();
        } else {
            r.run();
        }
    }

    protected JsonObject doCallJson(Map<String, Object> options) {
        JsonObject root = new JsonObject();
        if (propertiesFunction != null) {
            if (propertiesFunction.isUseDefaultInstance()) {
                root.put("login", "Default Instance");
            } else {
                root.put("login", "Service Account Key File");
            }
            GcpVaultConfiguration gcp = getCamelContext().getVaultConfiguration().getGcpVaultConfiguration();
            if (gcp != null) {
                root.put("refreshEnabled", gcp.isRefreshEnabled());
                root.put("refreshPeriod", gcp.getRefreshPeriod());
            }
            if (secretsRefreshTask != null) {
                Instant last = secretsRefreshTask.getLastCheckTime();
                if (last != null) {
                    long timestamp = last.toEpochMilli();
                    root.put("lastCheckTimestamp", timestamp);
                    root.put("lastCheckAge", TimeUtils.printSince(timestamp));
                }
                last = secretsRefreshTask.getLastReloadTime();
                if (last != null) {
                    long timestamp = last.toEpochMilli();
                    root.put("lastReloadTimestamp", timestamp);
                    root.put("lastReloadAge", TimeUtils.printSince(timestamp));
                }
            }
            JsonArray arr = new JsonArray();
            root.put("secrets", arr);

            List<String> sorted = new ArrayList<>(propertiesFunction.getSecrets());
            Collections.sort(sorted);

            for (String sec : sorted) {
                JsonObject jo = new JsonObject();
                jo.put("name", sec);
                Instant last = secretsRefreshTask != null ? secretsRefreshTask.getUpdates().get(sec) : null;
                if (last != null) {
                    long timestamp = last.toEpochMilli();
                    jo.put("timestamp", timestamp);
                    jo.put("age", TimeUtils.printSince(timestamp));
                }
                arr.add(jo);
            }
        }
        return root;
    }

    protected void doStart() throws Exception {
        if (meterRegistry == null) {
            meterRegistry = MicrometerUtils.getOrCreateMeterRegistry(camelContext.getRegistry(), METRICS_REGISTRY_NAME);
        }

        try {
            MicrometerMessageHistoryService messageHistoryService
                    = camelContext.hasService(MicrometerMessageHistoryService.class);
            if (messageHistoryService == null) {
                messageHistoryService = new MicrometerMessageHistoryService();
                messageHistoryService.setPrettyPrint(isPrettyPrint());
                messageHistoryService.setMeterRegistry(getMeterRegistry());
                messageHistoryService.setPrettyPrint(isPrettyPrint());
                messageHistoryService.setDurationUnit(getDurationUnit());
                messageHistoryService.setMatchingTags(Tags.of(KIND, KIND_HISTORY));
                camelContext.addService(messageHistoryService);
            }
        } catch (Exception e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        }

    }

    public Exchange send() throws CamelExecutionException {
        DefaultFluentProducerTemplate clone = checkCloned();

         
        final Endpoint target = clone.target();

        Exchange result;
        Exchange exchange = clone.exchangeSupplier != null ? clone.exchangeSupplier.get() : null;
        if (exchange != null) {
            result = clone.template().send(target, exchange);
        } else {
            Processor proc = clone.processorSupplier != null ? clone.processorSupplier.get() : null;
            final Processor processor = proc != null ? proc : clone.defaultProcessor();
            result = clone.template().send(target, processor);
        }

         
        cloned = false;
        useDefaultEndpoint = true;

        return result;
    }

    private void setupCustomServices() {
        ModelJAXBContextFactory modelJAXBContextFactory = getBeanForType(ModelJAXBContextFactory.class);
        if (modelJAXBContextFactory != null) {
            LOG.info("Using custom ModelJAXBContextFactory: {}", modelJAXBContextFactory);
            getContext().getCamelContextExtension().addContextPlugin(ModelJAXBContextFactory.class, modelJAXBContextFactory);
        }
        ClassResolver classResolver = getBeanForType(ClassResolver.class);
        if (classResolver != null) {
            LOG.info("Using custom ClassResolver: {}", classResolver);
            getContext().setClassResolver(classResolver);
        }
        FactoryFinderResolver factoryFinderResolver = getBeanForType(FactoryFinderResolver.class);
        if (factoryFinderResolver != null) {
            LOG.info("Using custom FactoryFinderResolver: {}", factoryFinderResolver);
            getContext().getCamelContextExtension().addContextPlugin(FactoryFinderResolver.class, factoryFinderResolver);
        }
        ExecutorServiceManager executorServiceStrategy = getBeanForType(ExecutorServiceManager.class);
        if (executorServiceStrategy != null) {
            LOG.info("Using custom ExecutorServiceStrategy: {}", executorServiceStrategy);
            getContext().setExecutorServiceManager(executorServiceStrategy);
        }
        ThreadPoolFactory threadPoolFactory = getBeanForType(ThreadPoolFactory.class);
        if (threadPoolFactory != null) {
            LOG.info("Using custom ThreadPoolFactory: {}", threadPoolFactory);
            getContext().getExecutorServiceManager().setThreadPoolFactory(threadPoolFactory);
        }
        ProcessorFactory processorFactory = getBeanForType(ProcessorFactory.class);
        if (processorFactory != null) {
            LOG.info("Using custom ProcessorFactory: {}", processorFactory);
            getContext().getCamelContextExtension().addContextPlugin(ProcessorFactory.class, processorFactory);
        }
        Debugger debugger = getBeanForType(Debugger.class);
        if (debugger != null) {
            LOG.info("Using custom Debugger: {}", debugger);
            getContext().setDebugger(debugger);
        }
        setupUuidGenerator();
        NodeIdFactory nodeIdFactory = getBeanForType(NodeIdFactory.class);
        if (nodeIdFactory != null) {
            LOG.info("Using custom NodeIdFactory: {}", nodeIdFactory);
            getContext().getCamelContextExtension().addContextPlugin(NodeIdFactory.class, nodeIdFactory);
        }
        StreamCachingStrategy streamCachingStrategy = getBeanForType(StreamCachingStrategy.class);
        if (streamCachingStrategy != null) {
            LOG.info("Using custom StreamCachingStrategy: {}", streamCachingStrategy);
            getContext().setStreamCachingStrategy(streamCachingStrategy);
        }
        MessageHistoryFactory messageHistoryFactory = getBeanForType(MessageHistoryFactory.class);
        if (messageHistoryFactory != null) {
            LOG.info("Using custom MessageHistoryFactory: {}", messageHistoryFactory);
            getContext().setMessageHistoryFactory(messageHistoryFactory);
        }
        ReactiveExecutor reactiveExecutor = getBeanForType(ReactiveExecutor.class);
        if (reactiveExecutor != null) {
             
            getContext().getCamelContextExtension().setReactiveExecutor(reactiveExecutor);
        }
    }

    public KeyManager[] createKeyManagers() throws GeneralSecurityException, IOException {
        LOG.trace("Creating KeyManager[] from KeyManagersParameters [{}].", this);
        KeyManager[] keyManagers;

        String kmfAlgorithm = this.parsePropertyValue(this.getAlgorithm());
        if (kmfAlgorithm == null) {
            kmfAlgorithm = KeyManagerFactory.getDefaultAlgorithm();
        }

        KeyManagerFactory kmf;
        if (this.getProvider() == null) {
            kmf = KeyManagerFactory.getInstance(kmfAlgorithm);
        } else {
            kmf = KeyManagerFactory.getInstance(kmfAlgorithm, this.parsePropertyValue(this.getProvider()));
        }

        LOG.debug("KeyManagerFactory [{}], initialized from [{}], is using provider [{}] and algorithm [{}].",
                kmf, this, kmf.getProvider(), kmf.getAlgorithm());

        char[] kmfPassword = null;
        if (this.getKeyPassword() != null) {
            kmfPassword = this.parsePropertyValue(this.getKeyPassword()).toCharArray();
        }

        KeyStore ks = this.getKeyStore() == null ? null : this.getKeyStore().createKeyStore();

        kmf.init(ks, kmfPassword);
        keyManagers = kmf.getKeyManagers();

        LOG.debug("KeyManager[] [{}], initialized from KeyManagerFactory [{}].", keyManagers, kmf);

        return keyManagers;
    }

    public static void afterRouteSynchronizations(
            Route route, Exchange exchange, List<Synchronization> synchronizations, Logger log) {
         
        final List<Synchronization> copy = safeCopy(synchronizations);

         
        for (Synchronization synchronization : copy) {
            final SynchronizationRouteAware routeSynchronization = synchronization.getRouteSynchronization();
            if (routeSynchronization != null) {
                try {
                    log.trace("Invoking synchronization.onAfterRoute: {} with {}", synchronization, exchange);
                    routeSynchronization.onAfterRoute(route, exchange);
                } catch (Exception e) {
                     
                    log.warn("Exception occurred during onAfterRoute. This exception will be ignored.", e);
                }
            }
        }
    }

    public void onExchangeBegin(Exchange exchange) {
         
         
         
         
        UnitOfWork uow = exchange.getUnitOfWork();
        if (uow != null) {
            int level = uow.routeStackLevel(registerTemplates, registerKamelets);
            if (level <= 1) {
                super.onExchangeBegin(exchange);
            }
        } else {
            super.onExchangeBegin(exchange);
        }
    }

        public void run() {
            NonNamespaceOperation<Namespace, NamespaceList, Resource<Namespace>> w
                    = getEndpoint().getKubernetesClient().namespaces();

            String labelKey = getEndpoint().getKubernetesConfiguration().getLabelKey();
            String labelValue = getEndpoint().getKubernetesConfiguration().getLabelValue();
            String resourceName = getEndpoint().getKubernetesConfiguration().getResourceName();

            if (ObjectHelper.isNotEmpty(labelKey) && ObjectHelper.isNotEmpty(labelValue)) {
                w = (NonNamespaceOperation<Namespace, NamespaceList, Resource<Namespace>>) w.withLabel(labelKey, labelValue);
            } else if (ObjectHelper.isNotEmpty(resourceName)) {
                w = (NonNamespaceOperation<Namespace, NamespaceList, Resource<Namespace>>) getEndpoint().getKubernetesClient()
                        .namespaces().withName(resourceName);
            }

            watch = w.watch(new Watcher<>() {

                @Override
                public void eventReceived(Action action, Namespace resource) {
                    Exchange exchange = createExchange(false);
                    exchange.getIn().setBody(resource);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_ACTION, action);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_TIMESTAMP, System.currentTimeMillis());
                    try {
                        processor.process(exchange);
                    } catch (Exception e) {
                        getExceptionHandler().handleException("Error during processing", exchange, e);
                    } finally {
                        releaseExchange(exchange, false);
                    }
                }

                @Override
                public void onClose(WatcherException cause) {
                    if (cause != null) {
                        LOG.error(cause.getMessage(), cause);
                    }
                }
            });
        }

    public static String extractSourceName(String loc) {
        loc = stripSourceLocationLineNumber(loc);
        if (loc != null) {
            if (loc.contains(":")) {
                 
                loc = loc.substring(loc.indexOf(':') + 1);
                 
                loc = FileUtil.stripPath(loc);
            }
        }
        return loc;
    }

    protected QueryFactory createQueryFactory() {
        if (query != null) {
            return QueryBuilder.query(query);
        } else if (namedQuery != null) {
            return QueryBuilder.namedQuery(namedQuery);
        } else if (nativeQuery != null) {
            if (resultClass != null) {
                return QueryBuilder.nativeQuery(nativeQuery, resultClass);
            } else {
                return QueryBuilder.nativeQuery(nativeQuery);
            }
        } else {
            Class<?> entityType = getEndpoint().getEntityType();

            if (entityType == null) {
                return null;
            } else {
                 
                String name = getEntityName(entityType);
                if (name != null) {
                    return QueryBuilder.query("select x from " + name + " x");
                } else {
                     
                    return QueryBuilder.query("select x from " + entityType.getSimpleName() + " x");
                }
            }
        }
    }

    public static Method findMethod(Class<?> clazz, String name, Class<?>... paramTypes) {
        Objects.requireNonNull(clazz, "Class must not be null");
        Objects.requireNonNull(name, "Method name must not be null");
        Class<?> searchType = clazz;
        while (searchType != null) {
            Method[] methods = searchType.isInterface() ? searchType.getMethods() : searchType.getDeclaredMethods();
            for (Method method : methods) {
                if (name.equals(method.getName())
                        && (paramTypes == null || Arrays.equals(paramTypes, method.getParameterTypes()))) {
                    return method;
                }
            }
            searchType = searchType.getSuperclass();
        }
        return null;
    }

    private static byte[] exportPrivateKeyToPEM(PrivateKey privateKey) throws Exception {
        byte[] encoded = privateKey.getEncoded();
        String base64 = Base64.getEncoder().encodeToString(encoded);

         
        StringBuilder pem = new StringBuilder();
        pem.append("-----BEGIN PRIVATE KEY-----\n");
        for (int i = 0; i < base64.length(); i += 64) {
            pem.append(base64, i, Math.min(i + 64, base64.length())).append("\n");
        }
        pem.append("-----END PRIVATE KEY-----\n");
        return pem.toString().getBytes();
    }

    public Collection<DevConsole> loadDevConsoles(boolean force) {
        Collection<DevConsole> answer = new ArrayList<>();

        if (force) {
             
            ServiceHelper.stopService(devConsoleResolver);
            ServiceHelper.startService(devConsoleResolver);
        }
        try {
            LOG.trace("Searching for {} dev consoles", META_INF_SERVICES);
            Collection<Resource> resources = resolver.findResources(META_INF_SERVICES + "/*");
            if (LOG.isDebugEnabled()) {
                LOG.debug("Discovered {} dev consoles from classpath scanning", resources.size());
            }
            for (Resource resource : resources) {
                LOG.trace("Resource: {}", resource);
                if (acceptResource(resource)) {
                    String id = extractId(resource);
                    LOG.trace("Loading DevConsole: {}", id);
                    DevConsole dc = devConsoleResolver.resolveDevConsole(id);
                    if (dc != null) {
                        LOG.debug("Loaded DevConsole: {}/{}", dc.getGroup(), dc.getId());
                        answer.add(dc);
                    }
                }
            }
        } catch (Exception e) {
            LOG.warn("Error during scanning for custom dev-consoles on classpath due to: {}. This exception is ignored.",
                    e.getMessage());
        }

        return answer;
    }

    public void doStop() throws Exception {
        if (ObjectHelper.isEmpty(configuration.getAmazonKinesisClient())) {
            if (kinesisClient != null) {
                kinesisClient.close();
            } else if (Objects.nonNull(kinesisAsyncClient)) {
                kinesisAsyncClient.close();
            }
        }
        if (!configuration.isCborEnabled()) {
            System.clearProperty(CBOR_ENABLED.property());
        }
        super.doStop();
    }

    public static QName getQName(final String name) {
        QName qName = null;
        if (name != null) {
            try {
                qName = QName.valueOf(name);
            } catch (Exception ex) {
                LOG.warn("Cannot create QName: {}", ex.getMessage(), ex);
            }
        }
        return qName;
    }

    private void createMavenPom(Path settings, Path profile, Path pom, Set<String> deps) throws Exception {
        String[] ids = gav.split(":");

        Properties prop = new CamelCaseOrderedProperties();
        RuntimeUtil.loadProperties(prop, settings);
        String repos = getMavenRepositories(settings, prop, camelSpringBootVersion);

        CamelCatalog catalog = CatalogLoader.loadSpringBootCatalog(repos, camelSpringBootVersion, download);
        if (ObjectHelper.isEmpty(camelVersion)) {
            camelVersion = catalog.getLoadedVersion();
        }
        if (ObjectHelper.isEmpty(camelVersion)) {
            camelVersion = VersionHelper.extractCamelVersion();
        }

         
         
        String context;
        InputStream template = catalog.loadResource("camel-jbang", pomTemplateName);
        if (template != null) {
            context = IOHelper.loadText(template);
        } else {
            context = readResourceTemplate("templates/" + pomTemplateName);
        }

        context = context.replaceAll("\\{\\{ \\.GroupId }}", ids[0]);
        context = context.replaceAll("\\{\\{ \\.ArtifactId }}", ids[1]);
        context = context.replaceAll("\\{\\{ \\.Version }}", ids[2]);
        context = context.replaceAll("\\{\\{ \\.SpringBootVersion }}", springBootVersion);
        context = context.replaceAll("\\{\\{ \\.JavaVersion }}", javaVersion);
        context = context.replaceAll("\\{\\{ \\.CamelVersion }}", camelVersion);
        context = context.replaceAll("\\{\\{ \\.CamelSpringBootVersion }}",
                Objects.requireNonNullElseGet(camelSpringBootVersion, () -> camelVersion));
        context = context.replaceFirst("\\{\\{ \\.ProjectBuildOutputTimestamp }}", this.getBuildMavenProjectDate());

        context = replaceBuildProperties(context);

        if (repos == null || repos.isEmpty()) {
            context = context.replaceFirst("\\{\\{ \\.MavenRepositories }}", "");
        } else {
            String s = mavenRepositoriesAsPomXml(repos);
            context = context.replaceFirst("\\{\\{ \\.MavenRepositories }}", s);
        }

        List<MavenGav> gavs = new ArrayList<>();
        for (String dep : deps) {
            MavenGav gav = parseMavenGav(dep);
            String gid = gav.getGroupId();
            String aid = gav.getArtifactId();

             
            if ("org.apache.camel".equals(gid)) {
                ArtifactModel<?> am = catalog.modelFromMavenGAV("org.apache.camel.springboot", aid + "-starter", null);
                if (am != null) {
                     
                    gav.setGroupId(am.getGroupId());
                    gav.setArtifactId(am.getArtifactId());
                    gav.setVersion(null);  
                } else {
                     
                    gav.setVersion(camelVersion);
                }
            }
             
            if ("org.springframework.boot".equals(gid)) {
                gav.setVersion(null);  
            }
            gavs.add(gav);
        }

         
        gavs.sort(mavenGavComparator());

        StringBuilder sb = new StringBuilder();
        for (MavenGav gav : gavs) {
            sb.append("        <dependency>\n");
            sb.append("            <groupId>").append(gav.getGroupId()).append("</groupId>\n");
            sb.append("            <artifactId>").append(gav.getArtifactId()).append("</artifactId>\n");
            if (gav.getVersion() != null) {
                sb.append("            <version>").append(gav.getVersion()).append("</version>\n");
            }
            if (gav.getScope() != null) {
                sb.append("            <scope>").append(gav.getScope()).append("</scope>\n");
            }
            if ("lib".equals(gav.getPackaging())) {
                 
                sb.append("            <scope>system</scope>\n");
                sb.append("            <systemPath>\\$\\{project.basedir}/lib/").append(gav.getArtifactId()).append("-")
                        .append(gav.getVersion()).append(".jar</systemPath>\n");
            } else if ("camel-kamelets-utils".equals(gav.getArtifactId())) {
                 
                sb.append("            <exclusions>\n");
                sb.append("                <exclusion>\n");
                sb.append("                    <groupId>org.apache.camel</groupId>\n");
                sb.append("                    <artifactId>*</artifactId>\n");
                sb.append("                </exclusion>\n");
                sb.append("            </exclusions>\n");
            }
            sb.append("        </dependency>\n");
        }
        context = context.replaceFirst("\\{\\{ \\.CamelDependencies }}", sb.toString());

        IOHelper.writeText(context, Files.newOutputStream(pom));
    }

        protected boolean setPropertyOnComponent(
                Component component,
                String name,
                Object value) {
            switch (name) {
            case "additionalProperties": getOrCreateConfiguration((DebeziumOracleComponent) component).setAdditionalProperties((java.util.Map) value); return true;
            case "bridgeErrorHandler": ((DebeziumOracleComponent) component).setBridgeErrorHandler((boolean) value); return true;
            case "configuration": ((DebeziumOracleComponent) component).setConfiguration((org.apache.camel.component.debezium.oracle.configuration.OracleConnectorEmbeddedDebeziumConfiguration) value); return true;
            case "internalKeyConverter": getOrCreateConfiguration((DebeziumOracleComponent) component).setInternalKeyConverter((java.lang.String) value); return true;
            case "internalValueConverter": getOrCreateConfiguration((DebeziumOracleComponent) component).setInternalValueConverter((java.lang.String) value); return true;
            case "offsetCommitPolicy": getOrCreateConfiguration((DebeziumOracleComponent) component).setOffsetCommitPolicy((java.lang.String) value); return true;
            case "offsetCommitTimeoutMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setOffsetCommitTimeoutMs((long) value); return true;
            case "offsetFlushIntervalMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setOffsetFlushIntervalMs((long) value); return true;
            case "offsetStorage": getOrCreateConfiguration((DebeziumOracleComponent) component).setOffsetStorage((java.lang.String) value); return true;
            case "offsetStorageFileName": getOrCreateConfiguration((DebeziumOracleComponent) component).setOffsetStorageFileName((java.lang.String) value); return true;
            case "offsetStoragePartitions": getOrCreateConfiguration((DebeziumOracleComponent) component).setOffsetStoragePartitions((int) value); return true;
            case "offsetStorageReplicationFactor": getOrCreateConfiguration((DebeziumOracleComponent) component).setOffsetStorageReplicationFactor((int) value); return true;
            case "offsetStorageTopic": getOrCreateConfiguration((DebeziumOracleComponent) component).setOffsetStorageTopic((java.lang.String) value); return true;
            case "autowiredEnabled": ((DebeziumOracleComponent) component).setAutowiredEnabled((boolean) value); return true;
            case "archiveDestinationName": getOrCreateConfiguration((DebeziumOracleComponent) component).setArchiveDestinationName((java.lang.String) value); return true;
            case "archiveLogHours": getOrCreateConfiguration((DebeziumOracleComponent) component).setArchiveLogHours((long) value); return true;
            case "binaryHandlingMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setBinaryHandlingMode((java.lang.String) value); return true;
            case "columnExcludeList": getOrCreateConfiguration((DebeziumOracleComponent) component).setColumnExcludeList((java.lang.String) value); return true;
            case "columnIncludeList": getOrCreateConfiguration((DebeziumOracleComponent) component).setColumnIncludeList((java.lang.String) value); return true;
            case "columnPropagateSourceType": getOrCreateConfiguration((DebeziumOracleComponent) component).setColumnPropagateSourceType((java.lang.String) value); return true;
            case "connectionValidationTimeoutMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setConnectionValidationTimeoutMs((long) value); return true;
            case "converters": getOrCreateConfiguration((DebeziumOracleComponent) component).setConverters((java.lang.String) value); return true;
            case "customMetricTags": getOrCreateConfiguration((DebeziumOracleComponent) component).setCustomMetricTags((java.lang.String) value); return true;
            case "customSanitizePattern": getOrCreateConfiguration((DebeziumOracleComponent) component).setCustomSanitizePattern((java.lang.String) value); return true;
            case "databaseConnectionAdapter": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabaseConnectionAdapter((java.lang.String) value); return true;
            case "databaseDbname": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabaseDbname((java.lang.String) value); return true;
            case "databaseHostname": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabaseHostname((java.lang.String) value); return true;
            case "databaseOutServerName": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabaseOutServerName((java.lang.String) value); return true;
            case "databasePassword": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabasePassword((java.lang.String) value); return true;
            case "databasePdbName": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabasePdbName((java.lang.String) value); return true;
            case "databasePort": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabasePort((int) value); return true;
            case "databaseQueryTimeoutMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabaseQueryTimeoutMs((int) value); return true;
            case "databaseUrl": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabaseUrl((java.lang.String) value); return true;
            case "databaseUser": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabaseUser((java.lang.String) value); return true;
            case "datatypePropagateSourceType": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatatypePropagateSourceType((java.lang.String) value); return true;
            case "decimalHandlingMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setDecimalHandlingMode((java.lang.String) value); return true;
            case "errorsMaxRetries": getOrCreateConfiguration((DebeziumOracleComponent) component).setErrorsMaxRetries((int) value); return true;
            case "eventProcessingFailureHandlingMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setEventProcessingFailureHandlingMode((java.lang.String) value); return true;
            case "executorShutdownTimeoutMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setExecutorShutdownTimeoutMs((long) value); return true;
            case "extendedHeadersEnabled": getOrCreateConfiguration((DebeziumOracleComponent) component).setExtendedHeadersEnabled((boolean) value); return true;
            case "guardrailCollectionsLimitAction": getOrCreateConfiguration((DebeziumOracleComponent) component).setGuardrailCollectionsLimitAction((java.lang.String) value); return true;
            case "guardrailCollectionsMax": getOrCreateConfiguration((DebeziumOracleComponent) component).setGuardrailCollectionsMax((int) value); return true;
            case "heartbeatActionQuery": getOrCreateConfiguration((DebeziumOracleComponent) component).setHeartbeatActionQuery((java.lang.String) value); return true;
            case "heartbeatIntervalMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setHeartbeatIntervalMs((int) value); return true;
            case "heartbeatTopicsPrefix": getOrCreateConfiguration((DebeziumOracleComponent) component).setHeartbeatTopicsPrefix((java.lang.String) value); return true;
            case "includeSchemaChanges": getOrCreateConfiguration((DebeziumOracleComponent) component).setIncludeSchemaChanges((boolean) value); return true;
            case "includeSchemaComments": getOrCreateConfiguration((DebeziumOracleComponent) component).setIncludeSchemaComments((boolean) value); return true;
            case "incrementalSnapshotWatermarkingStrategy": getOrCreateConfiguration((DebeziumOracleComponent) component).setIncrementalSnapshotWatermarkingStrategy((java.lang.String) value); return true;
            case "intervalHandlingMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setIntervalHandlingMode((java.lang.String) value); return true;
            case "legacyDecimalHandlingStrategy": getOrCreateConfiguration((DebeziumOracleComponent) component).setLegacyDecimalHandlingStrategy((boolean) value); return true;
            case "lobEnabled": getOrCreateConfiguration((DebeziumOracleComponent) component).setLobEnabled((boolean) value); return true;
            case "logMiningArchiveLogOnlyMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningArchiveLogOnlyMode((boolean) value); return true;
            case "logMiningArchiveLogOnlyScnPollIntervalMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningArchiveLogOnlyScnPollIntervalMs((long) value); return true;
            case "logMiningBatchSizeDefault": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBatchSizeDefault((long) value); return true;
            case "logMiningBatchSizeIncrement": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBatchSizeIncrement((long) value); return true;
            case "logMiningBatchSizeMax": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBatchSizeMax((long) value); return true;
            case "logMiningBatchSizeMin": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBatchSizeMin((long) value); return true;
            case "logMiningBufferDropOnStop": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferDropOnStop((boolean) value); return true;
            case "logMiningBufferEhcacheEventsConfig": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferEhcacheEventsConfig((java.lang.String) value); return true;
            case "logMiningBufferEhcacheGlobalConfig": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferEhcacheGlobalConfig((java.lang.String) value); return true;
            case "logMiningBufferEhcacheProcessedtransactionsConfig": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferEhcacheProcessedtransactionsConfig((java.lang.String) value); return true;
            case "logMiningBufferEhcacheSchemachangesConfig": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferEhcacheSchemachangesConfig((java.lang.String) value); return true;
            case "logMiningBufferEhcacheTransactionsConfig": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferEhcacheTransactionsConfig((java.lang.String) value); return true;
            case "logMiningBufferInfinispanCacheEvents": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferInfinispanCacheEvents((java.lang.String) value); return true;
            case "logMiningBufferInfinispanCacheGlobal": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferInfinispanCacheGlobal((java.lang.String) value); return true;
            case "logMiningBufferInfinispanCacheProcessedTransactions": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferInfinispanCacheProcessedTransactions((java.lang.String) value); return true;
            case "logMiningBufferInfinispanCacheSchemaChanges": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferInfinispanCacheSchemaChanges((java.lang.String) value); return true;
            case "logMiningBufferInfinispanCacheTransactions": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferInfinispanCacheTransactions((java.lang.String) value); return true;
            case "logMiningBufferTransactionEventsThreshold": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferTransactionEventsThreshold((long) value); return true;
            case "logMiningBufferType": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferType((java.lang.String) value); return true;
            case "logMiningClientidExcludeList": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningClientidExcludeList((java.lang.String) value); return true;
            case "logMiningClientidIncludeList": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningClientidIncludeList((java.lang.String) value); return true;
            case "logMiningFlushTableName": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningFlushTableName((java.lang.String) value); return true;
            case "logMiningIncludeRedoSql": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningIncludeRedoSql((boolean) value); return true;
            case "logMiningPathDictionary": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningPathDictionary((java.lang.String) value); return true;
            case "logMiningQueryFilterMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningQueryFilterMode((java.lang.String) value); return true;
            case "logMiningReadonlyHostname": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningReadonlyHostname((java.lang.String) value); return true;
            case "logMiningRestartConnection": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningRestartConnection((boolean) value); return true;
            case "logMiningScnGapDetectionGapSizeMin": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningScnGapDetectionGapSizeMin((long) value); return true;
            case "logMiningScnGapDetectionTimeIntervalMaxMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningScnGapDetectionTimeIntervalMaxMs((long) value); return true;
            case "logMiningSessionMaxMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningSessionMaxMs((long) value); return true;
            case "logMiningSleepTimeDefaultMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningSleepTimeDefaultMs((long) value); return true;
            case "logMiningSleepTimeIncrementMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningSleepTimeIncrementMs((long) value); return true;
            case "logMiningSleepTimeMaxMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningSleepTimeMaxMs((long) value); return true;
            case "logMiningSleepTimeMinMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningSleepTimeMinMs((long) value); return true;
            case "logMiningStrategy": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningStrategy((java.lang.String) value); return true;
            case "logMiningTransactionRetentionMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningTransactionRetentionMs((long) value); return true;
            case "logMiningUsernameExcludeList": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningUsernameExcludeList((java.lang.String) value); return true;
            case "logMiningUsernameIncludeList": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningUsernameIncludeList((java.lang.String) value); return true;
            case "maxBatchSize": getOrCreateConfiguration((DebeziumOracleComponent) component).setMaxBatchSize((int) value); return true;
            case "maxQueueSize": getOrCreateConfiguration((DebeziumOracleComponent) component).setMaxQueueSize((int) value); return true;
            case "maxQueueSizeInBytes": getOrCreateConfiguration((DebeziumOracleComponent) component).setMaxQueueSizeInBytes((long) value); return true;
            case "messageKeyColumns": getOrCreateConfiguration((DebeziumOracleComponent) component).setMessageKeyColumns((java.lang.String) value); return true;
            case "notificationEnabledChannels": getOrCreateConfiguration((DebeziumOracleComponent) component).setNotificationEnabledChannels((java.lang.String) value); return true;
            case "notificationSinkTopicName": getOrCreateConfiguration((DebeziumOracleComponent) component).setNotificationSinkTopicName((java.lang.String) value); return true;
            case "openlineageIntegrationConfigFilePath": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlineageIntegrationConfigFilePath((java.lang.String) value); return true;
            case "openlineageIntegrationDatasetKafkaBootstrapServers": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlineageIntegrationDatasetKafkaBootstrapServers((java.lang.String) value); return true;
            case "openlineageIntegrationEnabled": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlineageIntegrationEnabled((boolean) value); return true;
            case "openlineageIntegrationJobDescription": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlineageIntegrationJobDescription((java.lang.String) value); return true;
            case "openlineageIntegrationJobNamespace": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlineageIntegrationJobNamespace((java.lang.String) value); return true;
            case "openlineageIntegrationJobOwners": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlineageIntegrationJobOwners((java.lang.String) value); return true;
            case "openlineageIntegrationJobTags": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlineageIntegrationJobTags((java.lang.String) value); return true;
            case "openlogreplicatorHost": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlogreplicatorHost((java.lang.String) value); return true;
            case "openlogreplicatorPort": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlogreplicatorPort((int) value); return true;
            case "openlogreplicatorSource": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlogreplicatorSource((java.lang.String) value); return true;
            case "pollIntervalMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setPollIntervalMs((long) value); return true;
            case "postProcessors": getOrCreateConfiguration((DebeziumOracleComponent) component).setPostProcessors((java.lang.String) value); return true;
            case "provideTransactionMetadata": getOrCreateConfiguration((DebeziumOracleComponent) component).setProvideTransactionMetadata((boolean) value); return true;
            case "queryFetchSize": getOrCreateConfiguration((DebeziumOracleComponent) component).setQueryFetchSize((int) value); return true;
            case "racNodes": getOrCreateConfiguration((DebeziumOracleComponent) component).setRacNodes((java.lang.String) value); return true;
            case "retriableRestartConnectorWaitMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setRetriableRestartConnectorWaitMs((long) value); return true;
            case "schemaHistoryInternal": getOrCreateConfiguration((DebeziumOracleComponent) component).setSchemaHistoryInternal((java.lang.String) value); return true;
            case "schemaHistoryInternalFileFilename": getOrCreateConfiguration((DebeziumOracleComponent) component).setSchemaHistoryInternalFileFilename((java.lang.String) value); return true;
            case "schemaHistoryInternalSkipUnparseableDdl": getOrCreateConfiguration((DebeziumOracleComponent) component).setSchemaHistoryInternalSkipUnparseableDdl((boolean) value); return true;
            case "schemaHistoryInternalStoreOnlyCapturedDatabasesDdl": getOrCreateConfiguration((DebeziumOracleComponent) component).setSchemaHistoryInternalStoreOnlyCapturedDatabasesDdl((boolean) value); return true;
            case "schemaHistoryInternalStoreOnlyCapturedTablesDdl": getOrCreateConfiguration((DebeziumOracleComponent) component).setSchemaHistoryInternalStoreOnlyCapturedTablesDdl((boolean) value); return true;
            case "schemaNameAdjustmentMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setSchemaNameAdjustmentMode((java.lang.String) value); return true;
            case "signalDataCollection": getOrCreateConfiguration((DebeziumOracleComponent) component).setSignalDataCollection((java.lang.String) value); return true;
            case "signalEnabledChannels": getOrCreateConfiguration((DebeziumOracleComponent) component).setSignalEnabledChannels((java.lang.String) value); return true;
            case "signalPollIntervalMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setSignalPollIntervalMs((long) value); return true;
            case "skippedOperations": getOrCreateConfiguration((DebeziumOracleComponent) component).setSkippedOperations((java.lang.String) value); return true;
            case "snapshotDatabaseErrorsMaxRetries": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotDatabaseErrorsMaxRetries((int) value); return true;
            case "snapshotDelayMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotDelayMs((long) value); return true;
            case "snapshotFetchSize": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotFetchSize((int) value); return true;
            case "snapshotIncludeCollectionList": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotIncludeCollectionList((java.lang.String) value); return true;
            case "snapshotLockingMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotLockingMode((java.lang.String) value); return true;
            case "snapshotLockTimeoutMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotLockTimeoutMs((long) value); return true;
            case "snapshotMaxThreads": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotMaxThreads((int) value); return true;
            case "snapshotMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotMode((java.lang.String) value); return true;
            case "snapshotModeConfigurationBasedSnapshotData": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotModeConfigurationBasedSnapshotData((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotOnDataError": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotModeConfigurationBasedSnapshotOnDataError((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotOnSchemaError": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotModeConfigurationBasedSnapshotOnSchemaError((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotSchema": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotModeConfigurationBasedSnapshotSchema((boolean) value); return true;
            case "snapshotModeConfigurationBasedStartStream": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotModeConfigurationBasedStartStream((boolean) value); return true;
            case "snapshotModeCustomName": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotModeCustomName((java.lang.String) value); return true;
            case "snapshotSelectStatementOverrides": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotSelectStatementOverrides((java.lang.String) value); return true;
            case "snapshotTablesOrderByRowCount": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotTablesOrderByRowCount((java.lang.String) value); return true;
            case "sourceinfoStructMaker": getOrCreateConfiguration((DebeziumOracleComponent) component).setSourceinfoStructMaker((java.lang.String) value); return true;
            case "streamingDelayMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setStreamingDelayMs((long) value); return true;
            case "tableExcludeList": getOrCreateConfiguration((DebeziumOracleComponent) component).setTableExcludeList((java.lang.String) value); return true;
            case "tableIncludeList": getOrCreateConfiguration((DebeziumOracleComponent) component).setTableIncludeList((java.lang.String) value); return true;
            case "timePrecisionMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setTimePrecisionMode((java.lang.String) value); return true;
            case "tombstonesOnDelete": getOrCreateConfiguration((DebeziumOracleComponent) component).setTombstonesOnDelete((boolean) value); return true;
            case "topicNamingStrategy": getOrCreateConfiguration((DebeziumOracleComponent) component).setTopicNamingStrategy((java.lang.String) value); return true;
            case "topicPrefix": getOrCreateConfiguration((DebeziumOracleComponent) component).setTopicPrefix((java.lang.String) value); return true;
            case "transactionMetadataFactory": getOrCreateConfiguration((DebeziumOracleComponent) component).setTransactionMetadataFactory((java.lang.String) value); return true;
            case "unavailableValuePlaceholder": getOrCreateConfiguration((DebeziumOracleComponent) component).setUnavailableValuePlaceholder((java.lang.String) value); return true;
            default: return false;
            }
        }

    public void stopView(String namespace) throws Exception {
        LockHelper.doWithWriteLockT(
                lock,
                () -> {
                    ViewHolder<T> holder = views.get(namespace);

                    if (holder != null) {
                        LOG.info("Force stop of view {}", namespace);
                        holder.stopView();
                    } else {
                        LOG.warn("Error forcing stop of view {}: it does not exist", namespace);
                    }
                });
    }

    protected String doCallText(Map<String, Object> options) {
        StringBuilder sb = new StringBuilder();

        if (propertiesFunction != null) {
            sb.append("GCP Secret Manager:");
            if (propertiesFunction.isUseDefaultInstance()) {
                sb.append("\n    Login: Default Instance");
            } else {
                sb.append("\n    Login: Service Account Key File");
            }
            GcpVaultConfiguration gcp = getCamelContext().getVaultConfiguration().getGcpVaultConfiguration();
            if (gcp != null) {
                sb.append(String.format("\n    Refresh Enabled: %s", gcp.isRefreshEnabled()));
                sb.append(String.format("\n    Refresh Period: %s", gcp.getRefreshPeriod()));
            }
            if (secretsRefreshTask != null) {
                Instant last = secretsRefreshTask.getLastCheckTime();
                String s = last != null ? TimeUtils.printSince(last.toEpochMilli()) : "none";
                sb.append(String.format("\n    Last Check: %s", s));
                last = secretsRefreshTask.getLastReloadTime();
                s = last != null ? TimeUtils.printSince(last.toEpochMilli()) : "none";
                sb.append(String.format("\n    Last Reload: %s", s));
            }
            sb.append("\n\nSecrets in use:");

            List<String> sorted = new ArrayList<>(propertiesFunction.getSecrets());
            Collections.sort(sorted);

            for (String sec : sorted) {
                Instant last = secretsRefreshTask != null ? secretsRefreshTask.getUpdates().get(sec) : null;
                String age = last != null ? TimeUtils.printSince(last.toEpochMilli()) : null;
                if (age != null) {
                    sb.append(String.format("\n    %s (age: %s)", sec, age));
                } else {
                    sb.append(String.format("\n    %s", sec));
                }
            }
        }

        return sb.toString();
    }

    private static DataLakeServiceClient createDataLakeServiceClientWithSas(
            final DataLakeConfiguration configuration) {
        AzureSasCredential sasCredential = configuration.getSasCredential();
        if (sasCredential == null) {
            LOG.trace("Using SAS signature to instantiate service client");
            sasCredential = new AzureSasCredential(configuration.getSasSignature());
        } else {
            LOG.trace("Using configured SAS instance to instantiate service client");
        }

        return new DataLakeServiceClientBuilder()
                .credential(sasCredential)
                .endpoint(buildAzureUri(configuration))
                .buildClient();
    }

    public Producer createProducer(
            CamelContext camelContext, String host,
            String verb, String basePath, String uriTemplate, String queryParameters, String consumes,
            String produces, RestConfiguration configuration, Map<String, Object> parameters)
            throws Exception {
         
        basePath = FileUtil.stripLeadingSeparator(basePath);
        uriTemplate = FileUtil.stripLeadingSeparator(uriTemplate);

         
        String scheme = "vertx-http:";
        String url = scheme + host;
        if (!ObjectHelper.isEmpty(basePath)) {
            url += "/" + basePath;
        }
        if (!ObjectHelper.isEmpty(uriTemplate)) {
            url += "/" + uriTemplate;
        }

        RestConfiguration config = configuration;
        if (config == null) {
            config = CamelContextHelper.getRestConfiguration(getCamelContext(), null, scheme);
        }

        Map<String, Object> map = new HashMap<>();
         
        if (config.getProducerComponent() == null || config.getProducerComponent().equals(scheme)) {
             
            if (config.getEndpointProperties() != null && !config.getEndpointProperties().isEmpty()) {
                map.putAll(config.getEndpointProperties());
            }
        }

         
        String query = URISupport.createQueryString(map);
        if (!query.isEmpty()) {
            url = url + "?" + query;
        }

        parameters = parameters != null ? new HashMap<>(parameters) : new HashMap<>();

         
         
         
        RestProducerFactoryHelper.setupComponentFor(url, camelContext, (Map<String, Object>) parameters.remove("component"));

        VertxHttpEndpoint endpoint = (VertxHttpEndpoint) camelContext.getEndpoint(url, parameters);
        String path = uriTemplate != null ? uriTemplate : basePath;
        HeaderFilterStrategy headerFilterStrategy
                = resolveAndRemoveReferenceParameter(parameters, "headerFilterStrategy", HeaderFilterStrategy.class);
        if (headerFilterStrategy != null) {
            endpoint.getConfiguration().setHeaderFilterStrategy(headerFilterStrategy);
        } else {
            endpoint.getConfiguration().setHeaderFilterStrategy(new VertxHttpRestHeaderFilterStrategy(path, queryParameters));
        }
         
        ServiceHelper.startService(endpoint);

        return endpoint.createProducer();
    }

    public boolean hasNext() {
        try {
            if (asn1InputStream == null) {
                return false;
            }
            boolean availableDataInCurrentEntry = asn1InputStream.available() > 0;
            if (!availableDataInCurrentEntry) {
                 
                parent = getNextElement();
                if (parent == null) {
                    asn1InputStream.close();
                    availableDataInCurrentEntry = false;
                } else {
                    availableDataInCurrentEntry = true;
                }
            }
            return availableDataInCurrentEntry;
        } catch (IOException exception) {
            throw new RuntimeCamelException(exception);
        }
    }

    protected Validator doCreateValidator() {
        if (definition.getRef() == null && definition.getClassName() == null) {
            throw new IllegalArgumentException("'ref' or 'type' must be specified for customValidator");
        }
        Validator validator;
        if (definition.getRef() != null) {
            validator = lookupByNameAndType(definition.getRef(), Validator.class);
            if (validator == null) {
                throw new IllegalArgumentException("Cannot find validator with ref:" + definition.getRef());
            }
            if (validator.getType() != null) {
                throw new IllegalArgumentException(
                        String.format("Validator '%s' is already in use. Please check if duplicate validator exists.",
                                definition.getRef()));
            }
        } else {
            Class<Validator> validatorClass
                    = camelContext.getClassResolver().resolveClass(definition.getClassName(), Validator.class);
            if (validatorClass == null) {
                throw new IllegalArgumentException("Cannot find validator class: " + definition.getClassName());
            }
             
            validator = camelContext.getInjector().newInstance(validatorClass, false);  
        }
        validator.setCamelContext(camelContext);
        return validator.setType(definition.getType());
    }

    public GetCommitFileProducer(GitHubEndpoint endpoint) throws Exception {
        super(endpoint);

        Registry registry = endpoint.getCamelContext().getRegistry();
        Object service = registry.lookupByName(GitHubConstants.GITHUB_DATA_SERVICE);
        if (service != null) {
            LOG.debug("Using DataService found in registry {}", service.getClass().getCanonicalName());
            dataService = (DataService) service;
        } else {
            dataService = new DataService();
        }
        initService(dataService);

        if (endpoint.getEncoding() != null) {
            encoding = endpoint.getEncoding();

            if (!encoding.equalsIgnoreCase(Blob.ENCODING_BASE64)
                    && !encoding.equalsIgnoreCase(Blob.ENCODING_UTF8)) {
                throw new IllegalArgumentException("Unknown encoding '" + encoding + "'");
            }
        }
    }

    public void process(Exchange exchange) {
        if (exchange.getIn().getBody() instanceof int[]) {
            int[] seed = exchange.getIn().getBody(int[].class);
            Image[] result = predict(exchange, seed);
            exchange.getIn().setBody(result);
        } else {
            throw new RuntimeCamelException("Data type is not supported. Body should be int[]");
        }
    }

    public void addRoutesBuilder(Class<?>... routeBuilder) {
        StringJoiner existing = new StringJoiner(",");
        if (routesBuilderClasses != null && !routesBuilderClasses.isEmpty()) {
            existing.add(routesBuilderClasses);
        }
        if (routeBuilder != null) {
            for (Class<?> clazz : routeBuilder) {
                existing.add(clazz.getName());
            }
        }
        setRoutesBuilderClasses(existing.toString());
    }

    public FluentProducerTemplate withHeaders(Map<String, Object> headers) {
        DefaultFluentProducerTemplate clone = checkCloned();

        if (clone.processorSupplier != null) {
            throw new IllegalArgumentException("Cannot use both withHeaders and withProcessor with FluentProducerTemplate");
        }

        Map<String, Object> map = clone.headers;
        if (map == null) {
            map = new LinkedHashMap<>();
            clone.headers = map;
        }
        map.putAll(headers);
        return clone;
    }

    protected void maybeDisconnectOnDone(Exchange exchange) throws InterruptedException {
        if (session == null) {
            return;
        }

         
        Boolean close;
        if (ExchangeHelper.isOutCapable(exchange)) {
            close = exchange.getOut().getHeader(MinaConstants.MINA_CLOSE_SESSION_WHEN_COMPLETE, Boolean.class);
        } else {
            close = exchange.getIn().getHeader(MinaConstants.MINA_CLOSE_SESSION_WHEN_COMPLETE, Boolean.class);
        }

         
        boolean disconnect = getEndpoint().getConfiguration().isDisconnect();
        if (close != null) {
            disconnect = close;
        }
        if (disconnect) {
            LOG.debug("Closing session when complete at address: {}", address);
            closeSessionIfNeededAndAwaitCloseInHandler(session);
        }
    }

    protected String doCallText(Map<String, Object> options) {
        StringBuilder sb = new StringBuilder();

        if (propertiesFunction != null) {
            sb.append("AWS Secrets Manager:");
            sb.append(String.format("\n    Region: %s", propertiesFunction.getRegion()));
            if (propertiesFunction.isDefaultCredentialsProvider()) {
                sb.append("\n    Login: DefaultCredentialsProvider");
            } else if (propertiesFunction.isProfleCredentialsProvider()) {
                sb.append("\n    Login: ProfileCredentialsProvider");
            } else {
                sb.append("\n    Login: Access and Secret Keys");
            }
            AwsVaultConfiguration aws = getCamelContext().getVaultConfiguration().getAwsVaultConfiguration();
            if (aws != null) {
                sb.append(String.format("\n    Refresh Enabled: %s", aws.isRefreshEnabled()));
                sb.append(String.format("\n    Refresh Period: %s", aws.getRefreshPeriod()));
            }
            if (secretsRefreshTask != null) {
                Instant last = secretsRefreshTask.getLastCheckTime();
                String s = last != null ? TimeUtils.printSince(last.toEpochMilli()) : "none";
                sb.append(String.format("\n    Last Check: %s", s));
                last = secretsRefreshTask.getLastReloadTime();
                s = last != null ? TimeUtils.printSince(last.toEpochMilli()) : "none";
                sb.append(String.format("\n    Last Reload: %s", s));
            }
            sb.append("\n\nSecrets in use:");

            List<String> sorted = new ArrayList<>(propertiesFunction.getSecrets());
            Collections.sort(sorted);

            for (String sec : sorted) {
                Instant last = secretsRefreshTask != null ? secretsRefreshTask.getUpdates().get(sec) : null;
                String age = last != null ? TimeUtils.printSince(last.toEpochMilli()) : null;
                if (age != null) {
                    sb.append(String.format("\n    %s (age: %s)", sec, age));
                } else {
                    sb.append(String.format("\n    %s", sec));
                }
            }
        }

        return sb.toString();
    }

    public Producer createProducer(
            CamelContext camelContext, String host,
            String verb, String basePath, String uriTemplate, String queryParameters,
            String consumes, String produces, RestConfiguration configuration, Map<String, Object> parameters)
            throws Exception {

         
        basePath = FileUtil.stripLeadingSeparator(basePath);
        uriTemplate = FileUtil.stripLeadingSeparator(uriTemplate);

         
        String url = host;
        if (!ObjectHelper.isEmpty(basePath)) {
            url += "/" + basePath;
        }
        if (!ObjectHelper.isEmpty(uriTemplate)) {
            url += "/" + uriTemplate;
        }

        RestConfiguration config = configuration;
        if (config == null) {
            config = CamelContextHelper.getRestConfiguration(getCamelContext(), null, "http");
        }

        Map<String, Object> map = new HashMap<>();
         
        if (config.getProducerComponent() == null || config.getProducerComponent().equals("http")) {
             
            map.put("httpMethod", verb);
            if (config.getEndpointProperties() != null && !config.getEndpointProperties().isEmpty()) {
                map.putAll(config.getEndpointProperties());
            }
        }

        url = HttpUtil.recreateUrl(map, url);

        parameters = parameters != null ? new HashMap<>(parameters) : new HashMap<>();

         
         
         
        RestProducerFactoryHelper.setupComponentFor(url, camelContext, (Map<String, Object>) parameters.remove("component"));

        HttpEndpoint endpoint = (HttpEndpoint) camelContext.getEndpoint(url, parameters);

        String path = uriTemplate != null ? uriTemplate : basePath;

        HeaderFilterStrategy headerFilterStrategy
                = resolveAndRemoveReferenceParameter(parameters, "headerFilterStrategy", HeaderFilterStrategy.class);
        if (headerFilterStrategy != null) {
            endpoint.setHeaderFilterStrategy(headerFilterStrategy);
        } else {
            endpoint.setHeaderFilterStrategy(new HttpRestHeaderFilterStrategy(path, queryParameters));
        }
         
        ServiceHelper.startService(endpoint);

        return endpoint.createProducer();
    }

    protected void autoConfigure(String key) {
        var config = new org.apache.camel.util.OrderedLocationProperties();
        config.putAll("camel-main", camelContext.getPropertiesComponent().loadProperties());

         
        InputStream is = getClass().getResourceAsStream("/auto-configure/" + key + ".java");
        if (is != null) {
            try {
                 
                DependencyDownloader downloader = camelContext.hasService(DependencyDownloader.class);
                 
                downloader.downloadHiddenDependency("org.apache.camel", "camel-joor", camelContext.getVersion());
                 
                String script = IOHelper.loadText(is);
                Language lan = camelContext.resolveLanguage("java");
                Expression exp = lan.createExpression(script);
                Object out = exp.evaluate(new DefaultExchange(camelContext), Object.class);
                if (ObjectHelper.isNotEmpty(out)) {
                    LOG.info("{}", out);
                }
            } catch (Exception e) {
                throw RuntimeCamelException.wrapRuntimeException(e);
            } finally {
                IOHelper.close(is);
            }
        }
    }

    public List<Processor> next() {
        if (!hasNext()) {
            return null;
        }
        List<Processor> answer = new ArrayList<>();
        answer.add(processor);
        if (fallbackProcessor != null) {
            answer.add(fallbackProcessor);
        }
        return answer;
    }

    private void deleteFunction(CloudFunctionsServiceClient client, Exchange exchange)
            throws InvalidPayloadException, InterruptedException, ExecutionException {
        Empty response = null;
        if (getConfiguration().isPojoRequest()) {
            DeleteFunctionRequest request = exchange.getIn().getMandatoryBody(DeleteFunctionRequest.class);
            response = client.deleteFunctionAsync(request).get();
        } else {
            CloudFunctionName cfName = CloudFunctionName.of(getConfiguration().getProject(),
                    getConfiguration().getLocation(), getConfiguration().getFunctionName());
            DeleteFunctionRequest request = DeleteFunctionRequest.newBuilder().setName(cfName.toString()).build();
            response = client.deleteFunctionAsync(request).get();
        }
        Message message = getMessageForResponse(exchange);
        message.setBody(response);
    }

    protected void doStop() throws Exception {
        ServiceHelper.stopService(map);

        if (scheduledExecutorService != null && stopScheduledExecutorService) {
            camelContext.getExecutorServiceManager().shutdown(scheduledExecutorService);
            scheduledExecutorService = null;
        }
        if (workerPool != null && stopWorkerPool) {
            camelContext.getExecutorServiceManager().shutdown(workerPool);
            workerPool = null;
        }
    }

    public boolean acquireExclusiveReadLock(GenericFileOperations<File> operations, GenericFile<File> file, Exchange exchange)
            throws Exception {
         
         
        File path = file.getFile();
        if (!path.exists()) {
            return false;
        }

         
        String key = asKey(exchange, file);
        boolean answer = false;
        try {
            answer = idempotentRepository.add(exchange, key);
        } catch (Exception e) {
            if (LOG.isTraceEnabled()) {
                LOG.trace("Cannot acquire read lock due to {}. Will skip the file: {}", e.getMessage(), file, e);
            }
        }
        if (!answer) {
             
            CamelLogger.log(LOG, readLockLoggingLevel, "Cannot acquire read lock. Will skip the file: " + file);
        }

        if (answer) {
             
            answer = rename.acquireExclusiveReadLock(operations, file, exchange);
            if (!answer) {
                 
                idempotentRepository.remove(exchange, key);
            }
        }
        return answer;
    }

    protected String getEndpointUri(Row r) {
        String u = r.uri;
        if (shortUri) {
            int pos = u.indexOf('?');
            if (pos > 0) {
                u = u.substring(0, pos);
            }
        }
        return u;
    }

    private void createSetVariableDefinitions(Object[] variableNamesAndExprs) {
        if (variableNamesAndExprs.length == 1 && variableNamesAndExprs[0] instanceof Map) {
            createVariablesFromMap((Map<?, ?>) variableNamesAndExprs[0]);
        } else if (variableNamesAndExprs.length % 2 != 0) {
            throw new IllegalArgumentException("Must be a Map or have an even number of arguments!");
        } else {
            for (int i = 0; i < variableNamesAndExprs.length; i += 2) {
                addVariable(variableNamesAndExprs[i], variableNamesAndExprs[i + 1]);
            }
        }
    }

    protected void initChannel(Channel ch) throws Exception {
         
        ChannelPipeline channelPipeline = ch.pipeline();

        SslHandler sslHandler = configureClientSSLOnDemand();
        if (sslHandler != null) {
             
             
            LOG.debug("Client SSL handler configured and added to the ChannelPipeline: {}", sslHandler);
            addToPipeline("ssl", channelPipeline, sslHandler);
        }

        List<ChannelHandler> decoders = producer.getConfiguration().getDecodersAsList();
        for (int x = 0; x < decoders.size(); x++) {
            ChannelHandler decoder = decoders.get(x);
            if (decoder instanceof ChannelHandlerFactory) {
                 
                decoder = ((ChannelHandlerFactory) decoder).newChannelHandler();
            }
            addToPipeline("decoder-" + x, channelPipeline, decoder);
        }

        List<ChannelHandler> encoders = producer.getConfiguration().getEncodersAsList();
        for (int x = 0; x < encoders.size(); x++) {
            ChannelHandler encoder = encoders.get(x);
            if (encoder instanceof ChannelHandlerFactory) {
                 
                encoder = ((ChannelHandlerFactory) encoder).newChannelHandler();
            }
            addToPipeline("encoder-" + x, channelPipeline, encoder);
        }

         
        if (producer.getConfiguration().getRequestTimeout() > 0) {
            if (LOG.isTraceEnabled()) {
                LOG.trace("Using request timeout {} millis", producer.getConfiguration().getRequestTimeout());
            }
            ChannelHandler timeout
                    = new ReadTimeoutHandler(producer.getConfiguration().getRequestTimeout(), TimeUnit.MILLISECONDS);
            addToPipeline("timeout", channelPipeline, timeout);
        }

         
        addToPipeline("handler", channelPipeline, new ClientChannelHandler(producer));

        LOG.trace("Created ChannelPipeline: {}", channelPipeline);
    }

    public static boolean isBoundaryDelimiter(final CharArrayBuffer buffer, ParserCursor cursor, String boundary) {
        ObjectHelper.notNull(buffer, "Buffer");
        ObjectHelper.notNull(boundary, "Boundary");

        String boundaryDelimiter = "--" + boundary;  
         

        if (cursor == null) {
            cursor = new ParserCursor(0, boundaryDelimiter.length());
        }

        int indexFrom = cursor.getPos();
        int indexTo = cursor.getUpperBound();

        if ((indexFrom + boundaryDelimiter.length()) > indexTo) {
            return false;
        }

        for (int i = indexFrom; i < indexTo; ++i) {
            if (buffer.charAt(i) != boundaryDelimiter.charAt(i)) {
                return false;
            }
        }

        return true;
    }

    public DocFlavor forMimeTypeUTF16BE(String flavor, String mimeType) {
        if (mimeType.equalsIgnoreCase("TEXT_HTML_UTF_16BE")) {
            if (flavor.equalsIgnoreCase("DocFlavor.BYTE_ARRAY")) {
                d = DocFlavor.BYTE_ARRAY.TEXT_HTML_UTF_16BE;
            } else if (flavor.equalsIgnoreCase("DocFlavor.INPUT_STREAM")) {
                d = DocFlavor.INPUT_STREAM.TEXT_HTML_UTF_16BE;
            } else if (flavor.equalsIgnoreCase("DocFlavor.URL")) {
                d = DocFlavor.URL.TEXT_HTML_UTF_16BE;
            }
        } else {
            if (flavor.equalsIgnoreCase("DocFlavor.BYTE_ARRAY")) {
                d = DocFlavor.BYTE_ARRAY.TEXT_PLAIN_UTF_16BE;
            } else if (flavor.equalsIgnoreCase("DocFlavor.INPUT_STREAM")) {
                d = DocFlavor.INPUT_STREAM.TEXT_PLAIN_UTF_16BE;
            } else if (flavor.equalsIgnoreCase("DocFlavor.URL")) {
                d = DocFlavor.URL.TEXT_PLAIN_UTF_16BE;
            }
        }

        return d;
    }

    public static String resolveCamelVersionFromSpringBoot(String repos, String camelSpringBootVersion, boolean download)
            throws Exception {
        DependencyDownloaderClassLoader cl = new DependencyDownloaderClassLoader(CatalogLoader.class.getClassLoader());
        MavenDependencyDownloader downloader = new MavenDependencyDownloader();
        downloader.setRepositories(repos);
        downloader.setClassLoader(cl);
        downloader.setDownload(download);
        try {
            downloader.start();

            List<MavenArtifact> artifacts
                    = downloader.downloadArtifacts("org.apache.camel.springboot", "camel-catalog-provider-springboot",
                            camelSpringBootVersion, true);
            for (MavenArtifact ma : artifacts) {
                String g = ma.getGav().getGroupId();
                String a = ma.getGav().getArtifactId();
                if ("org.apache.camel".equals(g) && "camel-catalog".equals(a)) {
                    return ma.getGav().getVersion();
                }
            }
        } finally {
            downloader.stop();
            downloader.close();
        }

        return null;
    }

    public void run() {
        startingTime = Instant.now();
        final CountDownLatch isWatchClosed = new CountDownLatch(1);
        Watch watch = kubernetesClient.configMaps().inNamespace(kubernetesClient.getNamespace()).watch(new Watcher<>() {
            @Override
            public void eventReceived(Action action, ConfigMap configMap) {
                switch (action.name()) {
                    case "MODIFIED":
                        if (isReloadEnabled()) {
                            if (matchSecret(configMap.getMetadata().getName())) {
                                LOG.info("Update for Kubernetes Configmaps: {} detected, triggering CamelContext reload",
                                        configMap.getMetadata().getName());
                                ContextReloadStrategy reload = camelContext.hasService(ContextReloadStrategy.class);
                                if (reload != null) {
                                     
                                    reload.onReload(this);
                                }
                            }
                        }
                        break;
                    default:
                        LOG.debug("Not watched event {}", action.name());
                }
            }

            @Override
            public void onClose(WatcherException e) {
                isWatchClosed.countDown();
            }
        });

         
        try {
            isWatchClosed.await();
        } catch (InterruptedException e) {
            LOG.debug("Interrupted while waiting for the watch to close: {}", e.getMessage());
            Thread.currentThread().interrupt();
        }
        watch.close();
    }

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }

        EndpointMappingKey other = (EndpointMappingKey) obj;
        if (lookupKey == null) {
            if (other.lookupKey != null) {
                return false;
            }
        } else if (!lookupKey.equals(other.lookupKey)) {
            return false;
        }
        return true;
    }

    public <T> Map<String, T> findByTypeWithName(Class<T> type) {
        Map<String, T> result = new HashMap<>();
         
        String keyPrefix = type.getName().replace('$', '/');
        kvClient = consul.keyValueClient();

        List<String> keys;
        try {
            keys = kvClient.getKeys(keyPrefix);
        } catch (ConsulException e) {
            return result;
        }

        if (keys != null) {
            Object obj;

            for (String key : keys) {
                 
                key = key.substring(key.lastIndexOf('/') + 1);
                obj = lookupByName(key.replace('$', '/'));
                if (type.isInstance(obj)) {
                    result.put(key, type.cast(obj));
                }
            }
        }
        return result;
    }

    public static String getHttpMethodFromParameters(Exchange exchange, Endpoint endpoint) {
        String queryStringHeader = (String) exchange.getIn().getHeader(Exchange.HTTP_QUERY);
        if (queryStringHeader != null) {
            String methodFromQuery = getMethodFromQueryString(queryStringHeader);
            if (methodFromQuery != null) {
                return methodFromQuery;
            }
        }

         
        int queryIndex = endpoint.getEndpointUri().indexOf('?');
        if (queryIndex != -1) {
            String queryString = endpoint.getEndpointUri().substring(queryIndex + 1);
            String methodFromQuery = getMethodFromQueryString(queryString);
            if (methodFromQuery != null) {
                return methodFromQuery;
            }
        }
        return null;
    }

    public static URL resolveMandatoryResourceAsUrl(CamelContext camelContext, String uri)
            throws FileNotFoundException, MalformedURLException {
        URL url = resolveResourceAsUrl(camelContext, uri);
        if (url == null) {
            String resolvedName = resolveUriPath(uri);
            throw new FileNotFoundException("Cannot find resource: " + resolvedName + " in classpath for URI: " + uri);
        } else {
            return url;
        }
    }

    private String getLoad(Row r) {
        String s1 = r.load01 != null ? r.load01 : "-";
        String s2 = r.load05 != null ? r.load05 : "-";
        String s3 = r.load15 != null ? r.load15 : "-";
        if ("0.00".equals(s1)) {
            s1 = "-";
        }
        if ("0.00".equals(s2)) {
            s2 = "-";
        }
        if ("0.00".equals(s3)) {
            s3 = "-";
        }
        if (s1.equals("-") && s2.equals("-") && s3.equals("-")) {
            return "0/0/0";
        }
        return s1 + "/" + s2 + "/" + s3;
    }

    public boolean process(final Exchange exchange, final AsyncCallback callback) {
        boolean done = false;

        try {
            switch (operationName) {
                case CREATE_JOB:
                    processCreateJob(exchange, callback);
                    break;
                case GET_JOB:
                    processGetJob(exchange, callback);
                    break;
                case CLOSE_JOB:
                    processCloseJob(exchange, callback);
                    break;
                case ABORT_JOB:
                    processAbortJob(exchange, callback);
                    break;
                case CREATE_BATCH:
                    processCreateBatch(exchange, callback);
                    break;
                case GET_BATCH:
                    processGetBatch(exchange, callback);
                    break;
                case GET_ALL_BATCHES:
                    processGetAllBatches(exchange, callback);
                    break;
                case GET_REQUEST:
                    processGetRequest(exchange, callback);
                    break;
                case GET_RESULTS:
                    processGetResults(exchange, callback);
                    break;
                case CREATE_BATCH_QUERY:
                    processCreateBatchQuery(exchange, callback);
                    break;
                case GET_QUERY_RESULT_IDS:
                    processGetQueryResultIds(exchange, callback);
                    break;
                case GET_QUERY_RESULT:
                    processGetQueryResult(exchange, callback);
                    break;
                default:
                    throw new SalesforceException("Unknown operation name: " + operationName.value(), null);
            }
        } catch (SalesforceException e) {
            exchange.setException(new SalesforceException(
                    String.format("Error processing %s: [%s] \"%s\"", operationName.value(), e.getStatusCode(), e.getMessage()),
                    e));
            callback.done(true);
            done = true;
        } catch (InvalidPayloadException | RuntimeException e) {
            exchange.setException(new SalesforceException(
                    String.format("Unexpected Error processing %s: \"%s\"", operationName.value(), e.getMessage()), e));
            callback.done(true);
            done = true;
        }

         
        return done;
    }

    protected void afterConfiguration(String uri, String remaining, Endpoint endpoint, Map<String, Object> parameters)
            throws Exception {
        AtomEndpoint atom = (AtomEndpoint) endpoint;
        if (atom.getFeedUri() != null) {
             
            return;
        }

         
         
        String feedUri;
        if (!parameters.isEmpty()) {
            URI remainingUri = URISupport.createRemainingURI(new URI(remaining), parameters);
            feedUri = remainingUri.toString();
        } else {
            feedUri = remaining;
        }

        atom.setFeedUri(feedUri);
    }

    protected TemplatedRouteDefinition createTemplatedRouteDefinition(String id) {
        TemplatedRouteDefinition templatedRoute = new TemplatedRouteDefinition();
        if (id != null) {
            templatedRoute.setRouteTemplateRef(id);
        }
        if (resource != null) {
            templatedRoute.setResource(resource);
        }
        CamelContextAware.trySetCamelContext(templatedRoute, camelContext);
        return templatedRoute;
    }

    public String getTraceLabel() {
        StringBuilder sb = new StringBuilder(256);

        sb.append("setVariables[");
        int variableIndex = 0;
        for (Expression expression : expressions) {
            if (variableIndex > 0) {
                sb.append("; ");
            }
            sb.append(variableNames.get(variableIndex++).toString());
            sb.append(", ");
            sb.append(expression.toString());
        }
        sb.append("]");
        return sb.toString();
    }

    public JobKey retrieveJobKey(Action action, ScheduledRouteDetails scheduledRouteDetails) {
        JobKey result = null;

        if (action == Action.START) {
            result = scheduledRouteDetails.getStartJobKey();
        } else if (action == Action.STOP) {
            result = scheduledRouteDetails.getStopJobKey();
        } else if (action == Action.SUSPEND) {
            result = scheduledRouteDetails.getSuspendJobKey();
        } else if (action == Action.RESUME) {
            result = scheduledRouteDetails.getResumeJobKey();
        }

        return result;
    }

    protected void doStop() throws Exception {
        super.doStop();

        LOG.debug("Stopping Kubernetes ConfigMap Consumer");
        if (executor != null) {
            KubernetesHelper.close(configMapWatcher, configMapWatcher::getWatch);

            if (getEndpoint() != null && getEndpoint().getCamelContext() != null) {
                getEndpoint().getCamelContext().getExecutorServiceManager().shutdownNow(executor);
            } else {
                executor.shutdownNow();
            }
        }
        executor = null;
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, byte[].class, ca.uhn.hl7v2.model.Message.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.hl7.HL7Converter.toByteArray((ca.uhn.hl7v2.model.Message) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, ca.uhn.hl7v2.model.Message.class, byte[].class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.hl7.HL7Converter.toMessage((byte[]) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, ca.uhn.hl7v2.model.Message.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.hl7.HL7Converter.toMessage((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.lang.String.class, ca.uhn.hl7v2.model.Message.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.hl7.HL7Converter.toString((ca.uhn.hl7v2.model.Message) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private Expression createIncExpression(CamelContext camelContext, final Expression leftExp) {
        return new Expression() {
            @Override
            public <T> T evaluate(Exchange exchange, Class<T> type) {
                Number num = leftExp.evaluate(exchange, Number.class);
                if (num != null) {
                    long val = num.longValue();
                    val++;

                     
                    Object left = leftExp.evaluate(exchange, Object.class);
                    try {
                        left = camelContext.getTypeConverter().mandatoryConvertTo(left.getClass(), exchange, val);
                    } catch (NoTypeConversionAvailableException e) {
                        throw RuntimeCamelException.wrapRuntimeCamelException(e);
                    }

                     
                    return camelContext.getTypeConverter().convertTo(type, left);
                }
                 
                Exception cause = new CamelExchangeException("Cannot evaluate " + leftExp + " as a number", exchange);
                throw RuntimeCamelException.wrapRuntimeCamelException(cause);
            }

            @Override
            public String toString() {
                return left + operator.toString();
            }
        };
    }

    private void processUpsertSobject(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {
        String sObjectName = determineSObjectName(exchange);
        String sObjectExtIdValue;
        final String sObjectExtIdName = getParameter(SOBJECT_EXT_ID_NAME, exchange, IGNORE_BODY, NOT_OPTIONAL);

         
        Object oldValue = null;
        final AbstractSObjectBase sObjectBase = exchange.getIn().getBody(AbstractSObjectBase.class);
        if (sObjectBase != null) {
            oldValue = getAndClearPropertyValue(sObjectBase, sObjectExtIdName);
            sObjectExtIdValue = oldValue.toString();
             
            sObjectBase.clearBaseFields();
        } else {
            sObjectExtIdValue = getParameter(SOBJECT_EXT_ID_VALUE, exchange, IGNORE_BODY, NOT_OPTIONAL);
        }

        final Object finalOldValue = oldValue;
        restClient.upsertSObject(sObjectName, sObjectExtIdName, sObjectExtIdValue, determineHeaders(exchange),
                getRequestStream(exchange), new RestClient.ResponseCallback() {
                    @Override
                    public void onResponse(InputStream response, Map<String, String> headers, SalesforceException exception) {
                        restoreFields(exchange, sObjectBase, null, sObjectExtIdName, finalOldValue);
                        processResponse(exchange, response, headers, exception, callback);
                    }
                });
    }

    public static <T> Supplier<T> memorize(ThrowingSupplier<T, ? extends Exception> supplier, Consumer<Exception> consumer) {
        final AtomicReference<T> valueHolder = new AtomicReference<>();
        return new Supplier<>() {
            @Override
            public T get() {
                T supplied = valueHolder.get();
                if (supplied == null) {
                    synchronized (valueHolder) {
                        supplied = valueHolder.get();
                        if (supplied == null) {
                            try {
                                supplied = Objects.requireNonNull(supplier.get(), "Supplier should not return null");
                                valueHolder.lazySet(supplied);
                            } catch (Exception e) {
                                consumer.accept(e);
                            }
                        }
                    }
                }
                return supplied;
            }
        };
    }

        private void initAdditionalCounters() {
            if (configuration.isExchangesSucceeded()) {
                this.exchangesSucceeded = createCounter(namingStrategy.getExchangesSucceededName(route),
                        "Number of successfully completed exchanges");
            }
            if (configuration.isExchangesFailed()) {
                this.exchangesFailed
                        = createCounter(namingStrategy.getExchangesFailedName(route),
                                "Number of failed exchanges");
            }
            if (configuration.isExchangesTotal()) {
                this.exchangesTotal
                        = createCounter(namingStrategy.getExchangesTotalName(route),
                                "Total number of processed exchanges");
            }
            if (configuration.isExternalRedeliveries()) {
                this.externalRedeliveries = createCounter(namingStrategy.getExternalRedeliveriesName(route),
                        "Number of external initiated redeliveries (such as from JMS broker)");
            }
            if (configuration.isFailuresHandled()) {
                this.failuresHandled
                        = createCounter(namingStrategy.getFailuresHandledName(route),
                                "Number of failures handled");
            }
            if (configuration.isLongTask()) {
                longTaskTimer = new OpenTelemetryLongTaskTimer(
                        route, meter, attributes, configuration, namingStrategy, longTaskTimeUnit);
            }
        }

    public void setCommitmentTypeIdDocumentationReferences(List<String> commitmentTypeIdDocumentationReferences) {
        if (commitmentTypeIdDocumentationReferences == null) {
            throw new IllegalArgumentException("Parameter 'commitmentTypeIdDocumentationReferences' is null");
        }
        for (String ref : commitmentTypeIdDocumentationReferences) {
            if (ref == null || ref.isEmpty()) {
                throw new IllegalArgumentException(
                        "At least one documentation reference of the commitment type is null or empty");
            }
        }
        this.commitmentTypeIdDocumentationReferences = new ArrayList<>(commitmentTypeIdDocumentationReferences);
    }

    protected String waitForDumpFile(Path dumpFile) {
        StopWatch watch = new StopWatch();
        while (watch.taken() < 5000) {
            try {
                 
                Thread.sleep(100);

                if (Files.exists(dumpFile)) {
                    try (InputStream is = Files.newInputStream(dumpFile)) {
                        return IOHelper.loadText(is);
                    }
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } catch (Exception e) {
                 
            }
        }
        return null;
    }

    protected void doStop() throws Exception {
        connectorsLock.lock();
        try {
            for (ConnectorRef connectorRef : connectors.values()) {
                connectorRef.connector.stop();
            }
            connectors.clear();
        } finally {
            connectorsLock.unlock();
        }

        super.doStop();
    }

    private Processor defaultProcessor() {
        return exchange -> {
            if (headers != null) {
                exchange.getIn().getHeaders().putAll(headers);
            }
            if (exchangeProperties != null) {
                exchange.getProperties().putAll(exchangeProperties);
            }
            if (body != null) {
                exchange.getIn().setBody(body);
            }
            if (variables != null) {
                variables.forEach((k, v) -> ExchangeHelper.setVariable(exchange, k, v));
            }
        };
    }

    private void startRobustConnectionMonitor() {
        Runnable connectionCheckRunnable = new Runnable() {
            @Override
            public void run() {
                try {
                    checkConnection();
                } catch (Exception e) {
                    LOG.warn("Ignoring an exception caught in the connection poller thread.", e);
                }
            }
        };
         
        getExecutor().scheduleAtFixedRate(connectionCheckRunnable, endpoint.getConnectionPollDelay(),
                endpoint.getConnectionPollDelay(), TimeUnit.SECONDS);
    }

    public static KafkaResumeStrategyConfigurationBuilder newEmptyBuilder() {
        final Properties producerProperties = new Properties();
        final Properties consumerProperties = new Properties();

        KafkaResumeStrategyConfigurationBuilder builder = new KafkaResumeStrategyConfigurationBuilder(
                producerProperties,
                consumerProperties);

        String groupId = UUID.randomUUID().toString();
        LOG.debug("Creating consumer with {}[{}]", ConsumerConfig.GROUP_ID_CONFIG, groupId);
        builder.withGroupId(groupId);
        builder.withEnableAutoCommit(true);

        return builder;
    }

    private boolean dumpReceiveFiles(Map<Long, Pid> pids, int tail, Date limit) {
        Set<String> names = new HashSet<>();
        List<Row> rows = new ArrayList<>();
        for (Pid pid : pids.values()) {
            Queue<String> queue = pid.fifo;
            if (queue != null) {
                for (String l : queue) {
                    names.add(pid.name);
                    List<Row> parsed = parseReceiveLine(pid, l);
                    if (parsed != null && !parsed.isEmpty()) {
                        rows.addAll(parsed);
                    }
                }
                pid.fifo.clear();
            }
        }

         
        if (names.size() > 1) {
             
            final Map<String, Long> lastTimestamp = new HashMap<>();
            rows.sort((r1, r2) -> {
                long t1 = r1.timestamp;
                long t2 = r2.timestamp;
                if (t1 == 0) {
                    t1 = lastTimestamp.get(r1.name);
                }
                if (t1 == 0) {
                    t1 = lastTimestamp.get(r2.name);
                }
                if (t1 == 0 && t2 == 0) {
                    return 0;
                } else if (t1 == 0) {
                    return -1;
                } else if (t2 == 0) {
                    return 1;
                }
                lastTimestamp.put(r1.name, t1);
                lastTimestamp.put(r2.name, t2);
                return Long.compare(t1, t2);
            });
        }
        if (tail > 0) {
             
            int pos = rows.size() - tail;
            if (pos > 0) {
                rows = rows.subList(pos, rows.size());
            }
        }

        for (Row r : rows) {
            printDump(r.name, pids.size(), r, limit);
        }
        return true;
    }

    public static String nodeValue(final int namespace, final ByteString node) {
        Objects.requireNonNull(namespace);
        Objects.requireNonNull(node);

        final StringBuilder builder = new StringBuilder("RAW(");
        appendNamespace(builder, namespace);
        builder.append(';');
        appendNodeId(builder, node);
        builder.append(')');
        return builder.toString();
    }

    public Object getHeader(String name, Object defaultValue) {
        Object answer = null;

        if (headers == null) {
             
            headers = createHeaders();
        }

        if (!headers.isEmpty()) {
            answer = headers.get(name);
        }
        return answer != null ? answer : defaultValue;
    }

    private long determineInitialDelay(final Exchange exchange, Athena2Configuration configuration) {
        Long initialDelay = exchange.getIn().getHeader(Athena2Constants.INITIAL_DELAY, Long.class);

        if (ObjectHelper.isEmpty(initialDelay)) {
            initialDelay = configuration.getInitialDelay();
        }

        if (ObjectHelper.isEmpty(initialDelay)) {
            initialDelay = determineDelay(exchange, configuration);
        }

        if (initialDelay < 0) {
            throw new IllegalArgumentException("AWS Athena initial delay must be >= 0");
        }

        return initialDelay;
    }

    public void startView(String namespace) throws Exception {
        LockHelper.doWithWriteLockT(
                lock,
                () -> {
                    ViewHolder<T> holder = views.get(namespace);

                    if (holder != null) {
                        LOG.info("Force start of view {}", namespace);
                        holder.startView();
                    } else {
                        LOG.warn("Error forcing start of view {}: it does not exist", namespace);
                    }
                });
    }

    public boolean loadRuntimeProviderVersion(String groupId, String artifactId, String version) {
        try {
            MavenDownloader mavenDownloader = downloader;
            if (customized) {
                mavenDownloader = mavenDownloader.customize(localRepository, connectTimeout, requestTimeout);
            }

            String gav = String.format("%s:%s:%s", groupId, artifactId, version);
            resolve(mavenDownloader, gav, version.contains("SNAPSHOT"));

            this.runtimeProviderVersion = version;
            return true;
        } catch (Exception e) {
            if (log) {
                LOGGER.warn("Cannot load runtime provider version {} due {}", version, e.getMessage(), e);
            }
            return false;
        }
    }

    private void addDelay(SendMessageBatchRequestEntry.Builder request, Exchange exchange) {
        Integer headerValue = exchange.getIn().getHeader(Sqs2Constants.DELAY_HEADER, Integer.class);
        Integer delayValue;
        if (headerValue == null) {
            LOG.trace("Using the config delay");
            delayValue = getEndpoint().getConfiguration().getDelaySeconds();
        } else {
            LOG.trace("Using the header delay");
            delayValue = headerValue;
        }
        LOG.trace("found delay: {}", delayValue);
        if (delayValue != null) {
            request.delaySeconds(delayValue);
        }
    }

    public void getQueryResult(
            String jobId, String batchId, String resultId, Map<String, List<String>> headers,
            final StreamResponseCallback callback) {
        final Request get = getRequest(HttpMethod.GET, batchResultUrl(jobId, batchId, resultId), headers);

         
        doHttpRequest(get, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                callback.onResponse(response, headers, ex);
            }
        });
    }

    public static void skipToBoundary(AS2SessionInputBuffer inbuffer, InputStream is, String boundary)
            throws HttpException {

        boolean foundEndBoundary;
        try {
            foundEndBoundary = false;
            CharArrayBuffer lineBuffer = new CharArrayBuffer(1024);
            while (inbuffer.readLine(lineBuffer, is) != -1) {
                final ParserCursor cursor = new ParserCursor(0, lineBuffer.length());
                if (isBoundaryDelimiter(lineBuffer, cursor, boundary)) {
                    foundEndBoundary = true;
                    break;
                }
                lineBuffer.clear();
            }
        } catch (Exception e) {
            throw new HttpException("Failed to read start boundary for body part", e);
        }

        if (!foundEndBoundary && boundary != null) {
            throw new HttpException("Failed to find start boundary for body part");
        }

    }

    private void deleteTranscriptionJob(TranscribeClient transcribeClient, Exchange exchange) throws InvalidPayloadException {
        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof DeleteTranscriptionJobRequest) {
                try {
                    transcribeClient.deleteTranscriptionJob((DeleteTranscriptionJobRequest) payload);
                } catch (AwsServiceException ase) {
                    LOG.trace("Delete Transcription Job command returned the error code {}", ase.awsErrorDetails().errorCode());
                    throw ase;
                }
            }
        } else {
            DeleteTranscriptionJobRequest.Builder builder = DeleteTranscriptionJobRequest.builder();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(Transcribe2Constants.TRANSCRIPTION_JOB_NAME))) {
                String jobName = exchange.getIn().getHeader(Transcribe2Constants.TRANSCRIPTION_JOB_NAME, String.class);
                builder.transcriptionJobName(jobName);
            }
            try {
                transcribeClient.deleteTranscriptionJob(builder.build());
            } catch (AwsServiceException ase) {
                LOG.trace("Delete Transcription Job command returned the error code {}", ase.awsErrorDetails().errorCode());
                throw ase;
            }
        }
    }

    public static String getBrokerURLFromConnectionFactory(BeanIntrospection bi, ConnectionFactory cf) {
         
        if (cf == null) {
            return null;
        }
        Map<String, Object> props = new HashMap<>();
        bi.getProperties(cf, props, null, false);
        Object url = props.get("brokerURL");
        if (url != null) {
            return url.toString();
        } else {
             
            ConnectionFactory ncf = (ConnectionFactory) props.get("connectionFactory");
            if (ncf != null) {
                return getBrokerURLFromConnectionFactory(bi, ncf);
            }
        }
        return artemisBrokerURL(cf);
    }

    public String toString() {
        StringBuilder builder = new StringBuilder();
        if (trustManager != null) {
            builder.append("TrustManagerType[trustManager=");
            builder.append(trustManager);
            builder.append("]");
        } else {
            builder.append("TrustManagerType[keyStore=");
            builder.append(keyStore);
            builder.append(", provider=");
            builder.append(provider);
            builder.append(", algorithm=");
            builder.append(algorithm);
            builder.append("]");
        }
        return builder.toString();
    }

    private boolean sleep() {
        LOG.trace("Exclusive read lock not granted. Sleeping for {} millis.", checkInterval);
        try {
            Thread.sleep(checkInterval);
            return false;
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            LOG.debug("Sleep interrupted while waiting for exclusive read lock, so breaking out");
            return true;
        }
    }

    private Router messageToRouter(Message message) {
        Router router = message.getBody(Router.class);

        if (router == null) {
            Map headers = message.getHeaders();
            RouterBuilder builder = Builders.router();

            StringHelper.notEmpty(message.getHeader(OpenstackConstants.NAME, String.class), "Name");
            builder.name(message.getHeader(OpenstackConstants.NAME, String.class));

            if (headers.containsKey(NeutronConstants.TENANT_ID)) {
                builder.tenantId(message.getHeader(NeutronConstants.TENANT_ID, String.class));
            }

            router = builder.build();
        }
        return router;
    }

    private AvroSchema computeIfAbsent(Exchange exchange) {
        if (this.schema != null) {
            return this.schema;
        }

        AvroSchema answer = exchange.getProperty(SchemaHelper.CONTENT_SCHEMA, AvroSchema.class);

        if (answer == null && exchange.getProperties().containsKey(SchemaHelper.SCHEMA)) {
            String schemaJson = exchange.getProperty(SchemaHelper.SCHEMA, String.class);
            Schema raw = new Schema.Parser(NameValidator.UTF_VALIDATOR).parse(schemaJson);
            answer = new AvroSchema(raw);
        }

        if (answer == null) {
            String contentClass = SchemaHelper.resolveContentClass(exchange, this.contentClass);
            if (contentClass != null) {
                answer = this.schemes.computeIfAbsent(contentClass, t -> {
                    Resource res = PluginHelper.getResourceLoader(exchange.getContext())
                            .resolveResource("classpath:schemas/" + SchemaType.AVRO.name().toLowerCase(Locale.US) + "/" + t
                                             + "." + SchemaType.AVRO.type());

                    try {
                        if (res.exists()) {
                            try (InputStream is = res.getInputStream()) {
                                if (is != null) {
                                    return Avro.mapper().schemaFrom(is);
                                }
                            }
                        }
                    } catch (Exception e) {
                        throw new RuntimeException(
                                "Unable to load Avro schema for type: " + t + ", resource: " + res.getLocation(), e);
                    }

                    try {
                        return Avro.mapper().schemaFor(Class.forName(contentClass));
                    } catch (JsonMappingException | ClassNotFoundException e) {
                        throw new RuntimeException(
                                "Unable to compute Avro schema for type: " + t, e);
                    }
                });
            }
        }

        if (answer != null) {
            this.schema = answer;
        }

        return answer;
    }

    public Publisher<Exchange> from(String uri) {
        final String name = publishedUriToStream.computeIfAbsent(uri, camelUri -> {
            try {
                String uuid = context.getUuidGenerator().generateUuid();

                RouteBuilder.addRoutes(context, rb -> rb.from(camelUri).to("reactive-streams:" + uuid));

                return uuid;
            } catch (Exception e) {
                throw new IllegalStateException("Unable to create source reactive stream from direct URI: " + uri, e);
            }
        });

        return fromStream(name);
    }

    private void listObjects(Exchange exchange, ClientConfigurations clientConfigurations) throws ObsException {
        ListObjectsRequest request = null;

         
        Object exchangeBody = exchange.getMessage().getBody();
        if (exchangeBody instanceof ListObjectsRequest) {
            request = (ListObjectsRequest) exchangeBody;
        } else if (exchangeBody instanceof String) {
            String strBody = (String) exchangeBody;
            try {
                request = new ObjectMapper().readValue(strBody, ListObjectsRequest.class);
            } catch (JsonProcessingException e) {
                LOG.warn(
                        "String request body must be a valid JSON representation of a ListObjectsRequest. Attempting to list objects from endpoint parameters");
            }
        }

         
        if (request == null) {
             
            if (ObjectHelper.isEmpty(clientConfigurations.getBucketName())) {
                LOG.error("No bucket name given");
                throw new IllegalArgumentException("Bucket name is mandatory to list objects");
            }
            request = new ListObjectsRequest(clientConfigurations.getBucketName());
        }

         
        ObjectListing result;
        List<ObsObject> objects = new ArrayList<>();
        do {
            result = obsClient.listObjects(request);
            objects.addAll(result.getObjects());
            request.setMarker(result.getNextMarker());
        } while (result.isTruncated());

        exchange.getMessage().setBody(gson.toJson(objects));
    }

    public BoxConfiguration getEndpointConfiguration(BoxApiName apiName) {
        BoxConfiguration result = null;
        switch (apiName) {
            case COLLABORATIONS:
                result = new BoxCollaborationsManagerEndpointConfiguration();
                break;
            case COMMENTS:
                result = new BoxCommentsManagerEndpointConfiguration();
                break;
            case EVENT_LOGS:
                result = new BoxEventLogsManagerEndpointConfiguration();
                break;
            case FILES:
                result = new BoxFilesManagerEndpointConfiguration();
                break;
            case FOLDERS:
                result = new BoxFoldersManagerEndpointConfiguration();
                break;
            case GROUPS:
                result = new BoxGroupsManagerEndpointConfiguration();
                break;
            case EVENTS:
                result = new BoxEventsManagerEndpointConfiguration();
                break;
            case SEARCH:
                result = new BoxSearchManagerEndpointConfiguration();
                break;
            case TASKS:
                result = new BoxTasksManagerEndpointConfiguration();
                break;
            case USERS:
                result = new BoxUsersManagerEndpointConfiguration();
                break;
        }
        return result;
    }

    public String dumpStepStatsAsXml(boolean fullStats) throws Exception {
        StringBuilder sb = new StringBuilder();
        sb.append("<camelContextStat")
                .append(String.format(" id=\"%s\" state=\"%s\" uptime=\"%s\"", getCamelId(), getState(), getUptimeMillis()));
         
        String stat = dumpStatsAsXml(fullStats);
        sb.append(" exchangesInflight=\"").append(getInflightExchanges()).append("\"");
        sb.append(" ").append(stat, 7, stat.length() - 2).append(">\n");

        MBeanServer server = getContext().getManagementStrategy().getManagementAgent().getMBeanServer();
        if (server != null) {
             
            String prefix = getContext().getManagementStrategy().getManagementAgent().getIncludeHostName() ? "*/" : "";
            ObjectName query = ObjectName
                    .getInstance(jmxDomain + ":context=" + prefix + getContext().getManagementName() + ",type=routes,*");
            Set<ObjectName> routes = server.queryNames(query, null);

            List<ManagedProcessorMBean> steps = new ArrayList<>();
             
            query = ObjectName
                    .getInstance(jmxDomain + ":context=" + prefix + getContext().getManagementName() + ",type=steps,*");
            Set<ObjectName> names = server.queryNames(query, null);
            for (ObjectName on : names) {
                ManagedStepMBean step
                        = context.getManagementStrategy().getManagementAgent().newProxyClient(on, ManagedStepMBean.class);
                steps.add(step);
            }
            steps.sort(new OrderProcessorMBeans());

             
            sb.append("  <routeStats>\n");
            for (ObjectName on : routes) {
                ManagedRouteMBean route
                        = context.getManagementStrategy().getManagementAgent().newProxyClient(on, ManagedRouteMBean.class);
                sb.append("    <routeStat")
                        .append(String.format(" id=\"%s\" state=\"%s\" uptime=\"%s\"", route.getRouteId(), route.getState(),
                                route.getUptimeMillis()));
                if (route.getRouteGroup() != null) {
                    sb.append(String.format(" group=\"%s\"", route.getRouteGroup()));
                }
                if (route.getSourceLocation() != null) {
                    sb.append(String.format(" sourceLocation=\"%s\"", route.getSourceLocation()));
                }

                 
                stat = route.dumpStatsAsXml(fullStats);
                sb.append(" exchangesInflight=\"").append(route.getExchangesInflight()).append("\"");
                sb.append(" ").append(stat, 7, stat.length() - 2).append(">\n");

                 
                sb.append("      <stepStats>\n");
                for (ManagedProcessorMBean step : steps) {
                     
                    if (route.getRouteId().equals(step.getRouteId())) {
                        int line = step.getSourceLineNumber() != null ? step.getSourceLineNumber() : -1;
                        sb.append("        <stepStat")
                                .append(String.format(
                                        " id=\"%s\" index=\"%s\" state=\"%s\" disabled=\"%s\" sourceLineNumber=\"%s\"",
                                        step.getProcessorId(), step.getIndex(), step.getState(), step.getDisabled(), line));
                         
                        stat = step.dumpStatsAsXml(fullStats);
                        sb.append(" exchangesInflight=\"").append(step.getExchangesInflight()).append("\"");
                        sb.append(" ").append(stat, 7, stat.length()).append("\n");
                    }
                    sb.append("      </stepStats>\n");
                }
                sb.append("    </stepStat>\n");
            }
            sb.append("  </routeStats>\n");
        }

        sb.append("</camelContextStat>");
        return sb.toString();
    }

    public void close() {
        if (acceptorThread != null) {
            lock.lock();
            try {
                try {
                     
                    if (serversocket != null) {
                        serversocket.close();
                    }
                } catch (IOException e) {
                    LOG.debug(e.getMessage(), e);
                } finally {
                    acceptorThread = null;
                    listenerService = null;
                }
            } finally {
                lock.unlock();
            }
        }
    }

    public void onPutAsync(Message message) {
        final BasicCache<Object, Object> cache = getCache(message);
        final Object key = message.getHeader(InfinispanConstants.KEY, configuration::getKey);
        final Object value = message.getHeader(InfinispanConstants.VALUE, configuration::getValue);
        final CompletableFuture<Object> result;

        if (hasLifespan(message)) {
            long lifespan = message.getHeader(InfinispanConstants.LIFESPAN_TIME, long.class);
            TimeUnit timeUnit = message.getHeader(InfinispanConstants.LIFESPAN_TIME_UNIT, TimeUnit.class);

            if (hasMaxIdleTime(message)) {
                long maxIdle = message.getHeader(InfinispanConstants.MAX_IDLE_TIME, long.class);
                TimeUnit maxIdleTimeUnit = message.getHeader(InfinispanConstants.MAX_IDLE_TIME_UNIT, TimeUnit.class);

                result = cache.putAsync(key, value, lifespan, timeUnit, maxIdle, maxIdleTimeUnit);
            } else {
                result = cache.putAsync(key, value, lifespan, timeUnit);
            }
        } else {
            result = cache.putAsync(key, value);
        }

        setResult(message, result);
    }

    public boolean release(Exchange exchange) {
        try {
             
            PooledExchange ee = (PooledExchange) exchange;
            ee.done();

             
            boolean inserted = pool.offer(exchange);

            if (statisticsEnabled) {
                if (inserted) {
                    statistics.released.increment();
                } else {
                    statistics.discarded.increment();
                }
            }
            return inserted;
        } catch (Exception e) {
            if (statisticsEnabled) {
                statistics.discarded.increment();
            }
            LOG.debug("Error resetting exchange: {}. This exchange is discarded.", exchange);
            return false;
        }
    }

    private boolean isValidGrep(String line) {
        if (grep == null) {
            return true;
        }
         
        line = unescapeAnsi(line);
        String after = StringHelper.after(line, "---", line);
        for (String g : grep) {
            boolean m = Pattern.compile("(?i)" + g).matcher(after).find();
            if (m) {
                return true;
            }
        }
        return false;
    }

    protected boolean isInputStreamNeededForObject(Object obj) {
        if (obj == null) {
            return false;
        }

        if (obj instanceof WrappedFile) {
            obj = ((WrappedFile<?>) obj).getFile();
        }
        if (obj instanceof File) {
             
             
            return true;
        }

         
        return false;
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.smooks.api.io.Source.class, org.apache.camel.WrappedFile.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.smooks.converter.SourceConverter.toURISource((org.apache.camel.WrappedFile) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.smooks.io.source.JavaSource.class, java.lang.Object.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.smooks.converter.SourceConverter.toJavaSource(value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.smooks.io.source.JavaSource.class, org.smooks.io.sink.JavaSink.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.smooks.converter.SourceConverter.toJavaSource((org.smooks.io.sink.JavaSink) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.smooks.io.source.JavaSourceWithoutEventStream.class, java.lang.Object.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.smooks.converter.SourceConverter.toJavaSourceWithoutEventStream(value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.smooks.io.source.StreamSource.class, java.io.InputStream.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.smooks.converter.SourceConverter.toStreamSource((java.io.InputStream) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.smooks.io.source.StringSource.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.smooks.converter.SourceConverter.toStringSource((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    public List<Processor> next() {
        if (!hasNext()) {
            return null;
        }
        List<Processor> answer = new ArrayList<>();
        if (tryProcessor != null) {
            answer.add(tryProcessor);
        }
        if (catchClauses != null && !catchClauses.isEmpty()) {
            answer.addAll(catchClauses);
        }
        if (finallyProcessor != null) {
            answer.add(finallyProcessor);
        }
        return answer;
    }

    protected void initChannel(Channel ch) throws Exception {
         
        ChannelPipeline channelPipeline = ch.pipeline();

        SslHandler sslHandler = configureServerSSLOnDemand();
        if (sslHandler != null) {
             
             
            LOG.debug("Server SSL handler configured and added as an interceptor against the ChannelPipeline: {}", sslHandler);
            addToPipeline("ssl", channelPipeline, sslHandler);
        }

        List<ChannelHandler> encoders = consumer.getConfiguration().getEncodersAsList();
        for (int x = 0; x < encoders.size(); x++) {
            ChannelHandler encoder = encoders.get(x);
            if (encoder instanceof ChannelHandlerFactory) {
                 
                encoder = ((ChannelHandlerFactory) encoder).newChannelHandler();
            }
            addToPipeline("encoder-" + x, channelPipeline, encoder);
        }

        List<ChannelHandler> decoders = consumer.getConfiguration().getDecodersAsList();
        for (int x = 0; x < decoders.size(); x++) {
            ChannelHandler decoder = decoders.get(x);
            if (decoder instanceof ChannelHandlerFactory) {
                 
                decoder = ((ChannelHandlerFactory) decoder).newChannelHandler();
            }
            addToPipeline("decoder-" + x, channelPipeline, decoder);
        }

        if (consumer.getConfiguration().isUsingExecutorService()) {
             
            EventExecutorGroup applicationExecutor = consumer.getEndpoint().getComponent().getExecutorService();
            addToPipeline("handler", channelPipeline, applicationExecutor, new ServerChannelHandler(consumer));
        } else {
             
            addToPipeline("handler", channelPipeline, new ServerChannelHandler(consumer));

        }
        LOG.trace("Created ChannelPipeline: {}", channelPipeline);
    }

    public String browseMessageAsXml(Integer index, Boolean includeBody) {
        List<Exchange> exchanges = getEndpoint().getExchanges();

        if (index >= exchanges.size()) {
            return null;
        }
        Exchange exchange = exchanges.get(index);
        if (exchange == null) {
            return null;
        }

        Message msg = exchange.getMessage();
        return MessageHelper.dumpAsXml(msg, includeBody);
    }

    public Producer createProducer() throws Exception {
        if (type == GitHubType.CLOSEPULLREQUEST) {
            return new ClosePullRequestProducer(this);
        } else if (type == GitHubType.PULLREQUESTCOMMENT) {
            return new PullRequestCommentProducer(this);
        } else if (type == GitHubType.PULLREQUESTSTATE) {
            return new PullRequestStateProducer(this);
        } else if (type == GitHubType.PULLREQUESTFILES) {
            return new PullRequestFilesProducer(this);
        } else if (type == GitHubType.GETCOMMITFILE) {
            return new GetCommitFileProducer(this);
        } else if (type == GitHubType.CREATEISSUE) {
            return new CreateIssueProducer(this);
        }
        throw new IllegalArgumentException("Cannot create producer with type " + type);
    }

    public void process(Exchange exchange) throws Exception {
        Object body = exchange.getIn().getBody();
        String result;
        if (body instanceof QAInput) {
            QAInput input = exchange.getIn().getBody(QAInput.class);
            result = predict(exchange, input);
        } else if (body instanceof String[]) {
            String[] strs = exchange.getIn().getBody(String[].class);
            if (strs.length < 2) {
                throw new RuntimeCamelException("Input String[] should have two elements");
            }
            QAInput input = new QAInput(strs[0], strs[1]);
            result = predict(exchange, input);
        } else {
            throw new RuntimeCamelException("Data type is not supported. Body should be String[] or QAInput");
        }
        exchange.getIn().setBody(result);
    }

    protected void doStop() throws Exception {
        if (connection != null) {
            for (IrcChannel channel : getEndpoint().getConfiguration().getChannelList()) {
                LOG.debug("Parting: {}", channel);
                connection.doPart(channel.getName());
            }
            connection.removeIRCEventListener(listener);
        }
        super.doStop();
    }

    private Integer doCallLocal() throws Exception {
        AtomicReference<KameletMain> ref = new AtomicReference<>();
        Run run = new Run(this.getMain()) {
            @Override
            protected int runKameletMain(KameletMain main) throws Exception {
                ref.set(main);
                return super.runKameletMain(main);
            }
        };
        run.empty = true;
        run.propertiesFiles = propertiesFiles;
        run.property = property;

         
        final CountDownLatch latch = new CountDownLatch(1);
        this.pid = ProcessHandle.current().pid();
        Path outputFile = writeSendData();
        Thread t = new Thread("CamelJBangSendStatus") {
            @Override
            public void run() {
                try {
                    showStatus(outputFile);
                } catch (Exception e) {
                     
                } finally {
                    latch.countDown();
                     
                    KameletMain main = ref.get();
                    if (main != null) {
                        main.completed();
                    }
                }
            }
        };
         
        t.start();

        Integer exit = run.call();
        latch.await(timeout + 10000, TimeUnit.MILLISECONDS);

        return exit;
    }

        private BiPredicate<String, Component> condition() {
            if (type.equals(Component.class)) {
                return this.condition != null
                        ? this.condition
                        : new BiPredicate<>() {
                            @Override
                            public boolean test(String s, Component language) {
                                return true;
                            }
                        };
            }

            if (condition == null) {
                return new BiPredicate<>() {
                    @Override
                    public boolean test(String name, Component target) {
                        return type.isAssignableFrom(target.getClass());
                    }
                };
            }

            return new BiPredicate<>() {
                @Override
                public boolean test(String name, Component target) {
                    return type.isAssignableFrom(target.getClass()) && condition.test(name, target);
                }
            };
        }

        protected void decodeStructuredContent(Exchange exchange, Map<String, Object> content) {
            final CloudEvent ce = cloudEvent();
            final Message message = exchange.getIn();

             
            ifNotEmpty(content.remove("data"), message::setBody);

            ifNotEmpty(content.remove(ce.mandatoryAttribute(CloudEvent.CAMEL_CLOUD_EVENT_DATA_CONTENT_TYPE).json()), val -> {
                message.setHeader(Exchange.CONTENT_TYPE, val);
            });

            for (CloudEvent.Attribute attribute : ce.attributes()) {
                ifNotEmpty(content.remove(attribute.json()), val -> {
                    message.setHeader(attribute.id(), val);
                });
            }

             
             
             
            content.forEach((key, val) -> {
                message.setHeader(key.toLowerCase(Locale.US), val);
            });
        }

    private void doHttpRequestWithJobResponse(JobResponseCallback callback, Request request) {
        doHttpRequest(request, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> responseHeaders, SalesforceException ex) {
                if (ex != null) {
                    callback.onResponse(null, responseHeaders, ex);
                    return;
                }
                Job responseJob = null;
                try {
                    responseJob = DefaultBulkApiV2Client.this.unmarshalResponse(response, request,
                            Job.class);
                } catch (SalesforceException e) {
                    ex = e;
                }
                callback.onResponse(responseJob, responseHeaders, ex);
            }
        });
    }

    public boolean add(final String key) {
         
        Boolean rc = transactionTemplate.execute(new TransactionCallback<Boolean>() {
            public Boolean doInTransaction(TransactionStatus status) {
                int count = queryForInt(key);
                if (count == 0) {
                    insert(key);
                    return Boolean.TRUE;
                } else {
                    return Boolean.FALSE;
                }
            }
        });
        return rc.booleanValue();
    }

    private void includeProcessorsText(ManagedRouteMBean mrb, StringBuilder sb, String filter, int max, AtomicInteger counter) {
        ManagedCamelContext mcc = getCamelContext().getCamelContextExtension().getContextPlugin(ManagedCamelContext.class);

        Collection<String> ids;
        try {
            ids = mrb.processorIds();
        } catch (Exception e) {
            return;
        }

         
        List<ManagedProcessorMBean> mps = new ArrayList<>();
        for (String id : ids) {
            ManagedProcessorMBean mp = mcc.getManagedProcessor(id);
            if (mp != null && accept(mp, filter)) {
                mps.add(mp);
            }
        }

         
        mps.sort(Comparator.comparingInt(ManagedProcessorMBean::getIndex));

        includeProcessorsText(getCamelContext(), sb, max, counter, mps);
    }

    private static int getIndex(GenericDeclaration declaration, TypeVariable<?> variable) {
        Type[] typeParameters = declaration.getTypeParameters();
        for (int i = 0; i < typeParameters.length; i++) {
            if (typeParameters[i] instanceof TypeVariable) {
                TypeVariable<?> variableArgument = (TypeVariable<?>) typeParameters[i];
                if (variableArgument.getName().equals(variable.getName())) {
                    return i;
                }
            }
        }
        return -1;
    }

    protected String doCallText(Map<String, Object> options) {
        StringBuilder sb = new StringBuilder();

        if (propertiesFunction != null) {
            sb.append("Azure Key Vault Secret Manager:");
            sb.append("\n    Login: Client Id/Client Secret");
            AzureVaultConfiguration azure = getCamelContext().getVaultConfiguration().getAzureVaultConfiguration();
            if (azure != null) {
                sb.append(String.format("\n    Refresh Enabled: %s", azure.isRefreshEnabled()));
                sb.append(String.format("\n    Refresh Period: %s", azure.getRefreshPeriod()));
            }
            if (secretsRefreshTask != null) {
                Instant last = secretsRefreshTask.getLastCheckTime();
                String s = last != null ? TimeUtils.printSince(last.toEpochMilli()) : "none";
                sb.append(String.format("\n    Last Check: %s", s));
                last = secretsRefreshTask.getLastReloadTime();
                s = last != null ? TimeUtils.printSince(last.toEpochMilli()) : "none";
                sb.append(String.format("\n    Last Reload: %s", s));
            }
            sb.append("\n\nSecrets in use:");

            List<String> sorted = new ArrayList<>(propertiesFunction.getSecrets());
            Collections.sort(sorted);

            for (String sec : sorted) {
                Instant last = secretsRefreshTask != null ? secretsRefreshTask.getUpdates().get(sec) : null;
                String age = last != null ? TimeUtils.printSince(last.toEpochMilli()) : null;
                if (age != null) {
                    sb.append(String.format("\n    %s (age: %s)", sec, age));
                } else {
                    sb.append(String.format("\n    %s", sec));
                }
            }
        }

        return sb.toString();
    }

    public void releaseExclusiveReadLockOnRollback(
            GenericFileOperations<File> operations, GenericFile<File> file, Exchange exchange)
            throws Exception {
        String key = asKey(exchange, file);
        if (removeOnRollback) {
            idempotentRepository.remove(exchange, key);
        } else {
             
            idempotentRepository.confirm(exchange, key);
        }

        rename.releaseExclusiveReadLockOnRollback(operations, file, exchange);
    }

    protected ScheduledExecutorService getExecutorService(
            ScheduledExecutorService executorService, String executorServiceRef) {
        lock.lock();
        try {
            if (executorService == null || executorService.isShutdown()) {
                 
                 
                if (executorServiceRef != null) {
                    executorService = lookupByNameAndType(executorServiceRef, ScheduledExecutorService.class);
                    if (executorService == null) {
                        ExecutorServiceManager manager = camelContext.getExecutorServiceManager();
                        ThreadPoolProfile profile = manager.getThreadPoolProfile(executorServiceRef);
                        executorService = manager.newScheduledThreadPool(this, executorServiceRef, profile);
                    }
                    if (executorService == null) {
                        throw new IllegalArgumentException("ExecutorService " + executorServiceRef + " not found in registry.");
                    }
                } else {
                     
                     
                     
                    executorService = null;
                }
            }
            return executorService;
        } finally {
            lock.unlock();
        }
    }

    public Exchange aggregate(Exchange oldExchange, Exchange newExchange) {
         
        Object objBody = newExchange.getIn().getBody();
        if (!(objBody instanceof BulkOperation[])) {
            throw new InvalidPayloadRuntimeException(newExchange, BulkOperation[].class);
        }

        BulkOperation[] newBody = (BulkOperation[]) objBody;
        BulkRequest.Builder builder = new BulkRequest.Builder();
        builder.operations(List.of(newBody));
        if (oldExchange != null) {
            BulkRequest request = oldExchange.getIn().getBody(BulkRequest.class);
            builder.operations(request.operations());
        }
        newExchange.getIn().setBody(builder.build());
        return oldExchange;
    }

    protected String doCallText(Map<String, Object> options) {
        StringBuilder sb = new StringBuilder();

        if (propertiesFunction != null) {
            sb.append("Kubernetes Config maps Cluster:");
            sb.append(String.format("\n    Master Url: %s", propertiesFunction.getClient().getMasterUrl()));
            sb.append("\n    Login: OAuth Token");
            KubernetesVaultConfiguration kubernetes
                    = getCamelContext().getVaultConfiguration().getKubernetesVaultConfiguration();
            if (kubernetes != null) {
                sb.append(String.format("\n    Refresh Enabled: %s", kubernetes.isRefreshEnabled()));
            }
            if (cmRefreshTask != null) {
                Instant start = cmRefreshTask.getStartingTime();
                String s = start != null ? TimeUtils.printSince(start.toEpochMilli()) : "none";
                sb.append(String.format("\n    Running Since: %s", s));
            }
            List<String> sorted = new ArrayList<>();
            if (kubernetes != null) {
                sb.append("\n\nSecrets in use:");

                sorted = new ArrayList<>(List.of(kubernetes.getSecrets().split(",")));
                Collections.sort(sorted);
            }

            for (String sec : sorted) {
                sb.append(String.format("\n    %s", sec));
            }
        }

        return sb.toString();
    }

    public KinesisAsyncClient getAsyncClient(final Kinesis2Endpoint endpoint) {
        lock.lock();
        try {
            if (Objects.isNull(kinesisAsyncClient)) {
                kinesisAsyncClient = endpoint.getConfiguration().getAmazonKinesisAsyncClient() != null
                        ? endpoint.getConfiguration().getAmazonKinesisAsyncClient()
                        : KinesisClientFactory.getKinesisAsyncClient(endpoint.getConfiguration());
            }
            return kinesisAsyncClient;
        } finally {
            lock.unlock();
        }
    }

    public SchemaFactory getSchemaFactory() {
        if (schemaFactory == null) {
            lock.lock();
            try {
                if (schemaFactory == null) {
                    schemaFactory = createSchemaFactory();
                }
            } finally {
                lock.unlock();
            }
        }
        return schemaFactory;
    }

    protected boolean doHasNext() {
        try {
            if (zipInputStream == null) {
                return false;
            }
            boolean availableDataInCurrentEntry = currentEntry != null;
            if (!availableDataInCurrentEntry) {
                 
                parent = getNextElement();
                if (parent == null) {
                    zipInputStream.close();
                } else {
                    availableDataInCurrentEntry = true;
                }
            }
            return availableDataInCurrentEntry;
        } catch (IOException exception) {
            throw new RuntimeCamelException(exception);
        }
    }

    protected String doCallText(Map<String, Object> options) {
        StringBuilder sb = new StringBuilder();

        if (propertiesFunction != null) {
            sb.append("Azure Key Vault Secret Manager:");
            sb.append("\n    Login: Client Id/Client Secret");
            AzureVaultConfiguration azure = getCamelContext().getVaultConfiguration().getAzureVaultConfiguration();
            if (azure != null) {
                sb.append(String.format("\n    Refresh Enabled: %s", azure.isRefreshEnabled()));
                sb.append(String.format("\n    Refresh Period: %s", azure.getRefreshPeriod()));
            }
            if (secretsRefreshTask != null) {
                Instant last = secretsRefreshTask.getLastCheckTime();
                String s = last != null ? TimeUtils.printSince(last.toEpochMilli()) : "none";
                sb.append(String.format("\n    Last Check: %s", s));
                last = secretsRefreshTask.getLastReloadTime();
                s = last != null ? TimeUtils.printSince(last.toEpochMilli()) : "none";
                sb.append(String.format("\n    Last Reload: %s", s));
            }
            sb.append("\n\nSecrets in use:");

            List<String> sorted = new ArrayList<>(propertiesFunction.getSecrets());
            Collections.sort(sorted);

            for (String sec : sorted) {
                Instant last = secretsRefreshTask != null ? secretsRefreshTask.getUpdates().get(sec) : null;
                String age = last != null ? TimeUtils.printSince(last.toEpochMilli()) : null;
                if (age != null) {
                    sb.append(String.format("\n    %s (age: %s)", sec, age));
                } else {
                    sb.append(String.format("\n    %s", sec));
                }
            }
        }

        return sb.toString();
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.util.Map.class, java.lang.Object.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.solr.converter.SolrResponseConverter.createSolrResponseMap(value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.solr.client.solrj.SolrResponse.class, java.lang.Object.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.solr.converter.SolrResponseConverter.createSolrResponse(value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.solr.client.solrj.response.QueryResponse.class, java.lang.Object.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.solr.converter.SolrResponseConverter.createQueryResponse(value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.solr.client.solrj.response.SolrPingResponse.class, java.lang.Object.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.solr.converter.SolrResponseConverter.createSolrPingResponse(value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    public void process(String uri, Function<? super Publisher<Exchange>, ?> processor) {
        try {
            context.addRoutes(new RouteBuilder() {
                @Override
                public void configure() throws Exception {
                    from(uri)
                            .process(exchange -> {
                                Exchange copy = exchange.copy();
                                Object result = processor.apply(Mono.just(copy));
                                exchange.getIn().setBody(result);
                            })
                            .process(unwrapStreamProcessorSupplier.get());
                }
            });
        } catch (Exception e) {
            throw new IllegalStateException("Unable to add reactive stream processor to the direct URI: " + uri, e);
        }
    }

    public void startView(String namespace) throws Exception {
        LockHelper.doWithWriteLockT(
                lock,
                () -> {
                    ViewHolder<T> holder = views.get(namespace);

                    if (holder != null) {
                        LOG.info("Force start of view {}", namespace);
                        holder.startView();
                    } else {
                        LOG.warn("Error forcing start of view {}: it does not exist", namespace);
                    }
                });
    }

    private static void parseApplicationPkcs7MimeCompressedEntity(
            HttpMessage message, InputStream is, AS2SessionInputBuffer inBuffer, ContentType contentType,
            String contentTransferEncoding)
            throws HttpException {
        ApplicationPkcs7MimeCompressedDataEntity applicationPkcs7MimeCompressedDataEntity = null;

        ObjectHelper.notNull(message, "message");
        ObjectHelper.notNull(inBuffer, "inBuffer");

        HttpEntity entity = ObjectHelper.notNull(EntityUtils.getMessageEntity(message), "message entity");

        if (entity instanceof ApplicationPkcs7MimeCompressedDataEntity) {
             
            return;
        }

        Args.check(entity.isStreaming(), "Message entity can not be parsed: entity is not streaming");

        try {

            applicationPkcs7MimeCompressedDataEntity
                    = parseApplicationPkcs7MimeCompressedDataEntityBody(inBuffer, is, null, contentType,
                            contentTransferEncoding);
            applicationPkcs7MimeCompressedDataEntity.setMainBody(true);

            EntityUtils.setMessageEntity(message, applicationPkcs7MimeCompressedDataEntity);

        } catch (Exception e) {
            throw new HttpException("Failed to parse entity content", e);
        }
    }

                    protected void setValues(PreparedStatement ps, LobCreator lobCreator) throws SQLException {
                        int totalParameterIndex = 0;
                        lobCreator.setBlobAsBytes(ps, ++totalParameterIndex, data);
                        ps.setLong(++totalParameterIndex, version + 1);
                        if (storeBodyAsText) {
                            ps.setString(++totalParameterIndex, exchange.getIn().getBody(String.class));
                        }
                        if (hasHeadersToStoreAsText()) {
                            for (String headerName : headersToStoreAsText) {
                                String headerValue = exchange.getIn().getHeader(headerName, String.class);
                                ps.setString(++totalParameterIndex, headerValue);
                            }
                        }
                        ps.setString(++totalParameterIndex, key);
                        ps.setLong(++totalParameterIndex, version);
                    }

    public void whenComplete(BiConsumer<BackOffTimer.Task, Throwable> whenCompleted) {
        lock.lock();
        try {
            if (backOff.isRemoveOnComplete()) {
                timer.remove(this);
            }
            consumers.add(whenCompleted);
        } finally {
            lock.unlock();
        }
    }

    public void setSigPolicyQualifiers(List<String> sigPolicyQualifiers) {
        if (sigPolicyQualifiers == null) {
            throw new IllegalArgumentException("Parameter 'sigPolicyQualifiers' is null");
        }
        for (String qualifier : sigPolicyQualifiers) {
            if (qualifier == null || qualifier.isEmpty()) {
                throw new IllegalArgumentException("At least one of the policy qualifiers is null or empty");
            }
        }
        this.sigPolicyQualifiers = new ArrayList<>(sigPolicyQualifiers);
    }

    public String getEndpointUri() {
        if (endpointConsumerBuilder != null) {
            return endpointConsumerBuilder.getRawUri();
        } else if (endpoint != null) {
            return endpoint.getEndpointUri();
        } else {
            return uri;
        }
    }

    private void runAsyncWaitContainer(Exchange exchange, Message message, DockerClient client) throws InterruptedException {
        try (WaitContainerCmd cmd = executeWaitContainerRequest(client, message)) {
            WaitContainerResultCallback item = cmd.exec(new WaitContainerResultCallback() {
                @Override
                public void onNext(WaitResponse item) {
                    super.onNext(item);

                    LOG.trace("wait container callback {}", item);
                }

            });

            setResponse(exchange, item);
        }
    }

    public static FileEventEnum valueOf(DirectoryChangeEvent.EventType directoryChangeEventType) {
        switch (directoryChangeEventType) {
            case CREATE:
                return FileEventEnum.CREATE;
            case DELETE:
                return FileEventEnum.DELETE;
            case MODIFY:
                return FileEventEnum.MODIFY;
            default:
                return null;
        }
    }

    public static String extractSourceName(String loc) {
        loc = stripSourceLocationLineNumber(loc);
        if (loc != null) {
            if (loc.contains(":")) {
                 
                loc = loc.substring(loc.indexOf(':') + 1);
                 
                loc = FileUtil.stripPath(loc);
            }
        }
        return loc != null ? loc : "";
    }

    private void processExecuteAsyncReport(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {

        String reportId;
        final Boolean includeDetails = getParameter(INCLUDE_DETAILS, exchange, IGNORE_BODY, IS_OPTIONAL, Boolean.class);

         
        ReportMetadata reportMetadata = exchange.getIn().getBody(ReportMetadata.class);
        if (reportMetadata != null) {
            reportId = reportMetadata.getId();
            if (reportId == null) {
                reportId = getParameter(REPORT_ID, exchange, IGNORE_BODY, NOT_OPTIONAL);
            }
        } else {
            reportId = getParameter(REPORT_ID, exchange, USE_BODY, NOT_OPTIONAL);
            reportMetadata = getParameter(REPORT_METADATA, exchange, IGNORE_BODY, IS_OPTIONAL, ReportMetadata.class);
        }

        analyticsClient.executeAsyncReport(reportId, includeDetails, reportMetadata, determineHeaders(exchange),
                new AnalyticsApiClient.ReportInstanceResponseCallback() {
                    @Override
                    public void onResponse(ReportInstance reportInstance, Map<String, String> headers, SalesforceException ex) {
                        processResponse(exchange, reportInstance, headers, ex, callback);
                    }
                });
    }

    public String getLabel() {
        if (endpointUriToString == null) {
            String value = null;
            try {
                value = getEndpointUri();
            } catch (RuntimeException e) {
                 
            }
             
            endpointUriToString = URISupport.sanitizeUri(value);
        }

        String uri = endpointUriToString;
        return "to[" + uri + "]";
    }

    public MilvusClient getClient() {
        if (this.client == null) {
            lock.lock();
            try {
                if (this.client == null) {
                    this.client = this.configuration.getClient();
                    this.closeClient = false;

                    if (this.client == null) {
                        this.client = createClient();
                        this.closeClient = true;
                    }
                }
            } finally {
                lock.unlock();
            }
        }

        return this.client;
    }

    public void process(Exchange exchange) throws Exception {

        if (logger.isDebugEnabled()) {
             
             
             
            logger.debug("uploader thread/id: {} / {}. api call completed.", Thread.currentThread().getId(),
                    exchange.getExchangeId());
        }

        if (exchange.getIn().getBody() instanceof List) {
            boolean groupedExchanges = false;
            for (Object body : exchange.getIn().getBody(List.class)) {
                if (body instanceof Exchange) {
                    send((Exchange) body);
                    groupedExchanges = true;
                }
            }
            if (!groupedExchanges) {
                send(exchange);
            }
        } else {
            send(exchange);
        }
    }

    public RemoteFileOperations<FTPFile> createRemoteFileOperations() throws Exception {
         
        FTPSClient client = getFtpsClient();

        if (client == null) {
             
             
            client = (FTPSClient) createFtpClient();
        }

         
         
        if (getBufferSize() > 0) {
            client.setBufferSize(getBufferSize());
        }
         
        if (getConfiguration().getConnectTimeout() > -1) {
            client.setConnectTimeout(getConfiguration().getConnectTimeout());
        }
        if (getConfiguration().getSoTimeout() > -1) {
            soTimeout = getConfiguration().getSoTimeout();
        }
        dataTimeout = getConfiguration().getTimeout();

        if (ftpClientParameters != null) {
            Map<String, Object> localParameters = new HashMap<>(ftpClientParameters);
             
             
            Object timeout = localParameters.remove("soTimeout");
            if (timeout != null) {
                soTimeout = getCamelContext().getTypeConverter().convertTo(int.class, timeout);
            }
             
            timeout = localParameters.remove("dataTimeout");
            if (timeout != null) {
                dataTimeout = getCamelContext().getTypeConverter().convertTo(int.class, timeout);
            }
            setProperties(client, localParameters);
        }

        if (ftpClientConfigParameters != null) {
             
             
            if (ftpClientConfig == null) {
                ftpClientConfig = new FTPClientConfig();
            }
            Map<String, Object> localConfigParameters = new HashMap<>(ftpClientConfigParameters);
            setProperties(ftpClientConfig, localConfigParameters);
        }

        if (dataTimeout > 0) {
            client.setDataTimeout(dataTimeout);
        }

        if (LOG.isDebugEnabled()) {
            LOG.debug("Created FTPSClient[connectTimeout: {}, soTimeout: {}, dataTimeout: {}, bufferSize: {}"
                      + ", receiveDataSocketBufferSize: {}, sendDataSocketBufferSize: {}]: {}",
                    client.getConnectTimeout(), getSoTimeout(), dataTimeout, client.getBufferSize(),
                    client.getReceiveDataSocketBufferSize(), client.getSendDataSocketBufferSize(), client);
        }

        FtpsOperations operations = new FtpsOperations(client, getFtpClientConfig());
        operations.setEndpoint(this);
        return operations;
    }

    public static <T> Optional<T> firstMatching(Predicate<T> predicate, ThrowingSupplier<T, Exception>... suppliers)
            throws Exception {
        T answer = null;

        for (ThrowingSupplier<T, Exception> supplier : suppliers) {
            answer = supplier.get();
            if (predicate.test(answer)) {
                break;
            }
        }

        return Optional.ofNullable(answer);
    }

        public void run() {
            FilterWatchListDeletable<ConfigMap, ConfigMapList, Resource<ConfigMap>> w;

             
            String namespace = getEndpoint().getKubernetesConfiguration().getNamespace();
            String labelKey = getEndpoint().getKubernetesConfiguration().getLabelKey();
            String labelValue = getEndpoint().getKubernetesConfiguration().getLabelValue();
            String resourceName = getEndpoint().getKubernetesConfiguration().getResourceName();

            if (ObjectHelper.isEmpty(namespace)) {
                w = getEndpoint().getKubernetesClient().configMaps().inAnyNamespace();

                if (ObjectHelper.isNotEmpty(labelKey) && ObjectHelper.isNotEmpty(labelValue)) {
                    w = w.withLabel(labelKey, labelValue);
                }
            } else {
                final NonNamespaceOperation<ConfigMap, ConfigMapList, Resource<ConfigMap>> client
                        = getEndpoint().getKubernetesClient().configMaps().inNamespace(namespace);
                w = client;
                if (ObjectHelper.isNotEmpty(labelKey) && ObjectHelper.isNotEmpty(labelValue)) {
                    w = client.withLabel(labelKey, labelValue);
                } else if (ObjectHelper.isNotEmpty(resourceName)) {
                    w = (FilterWatchListDeletable<ConfigMap, ConfigMapList, Resource<ConfigMap>>) client.withName(resourceName);
                }
            }

            watch = w.watch(new Watcher<>() {

                @Override
                public void eventReceived(Action action, ConfigMap resource) {
                    Exchange exchange = createExchange(false);
                    exchange.getIn().setBody(resource);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_ACTION, action);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_TIMESTAMP, System.currentTimeMillis());
                    try {
                        processor.process(exchange);
                    } catch (Exception e) {
                        getExceptionHandler().handleException("Error during processing", exchange, e);
                    } finally {
                        releaseExchange(exchange, false);
                    }
                }

                @Override
                public void onClose(WatcherException cause) {
                    if (cause != null) {
                        LOG.error(cause.getMessage(), cause);
                    }
                }
            });
        }

    public Exchange send() throws CamelExecutionException {
        DefaultFluentProducerTemplate clone = checkCloned();

         
        final Endpoint target = clone.target();

        Exchange result;
        Exchange exchange = clone.exchangeSupplier != null ? clone.exchangeSupplier.get() : null;
        if (exchange != null) {
            result = clone.template().send(target, exchange);
        } else {
            Processor proc = clone.processorSupplier != null ? clone.processorSupplier.get() : null;
            final Processor processor = proc != null ? proc : clone.defaultProcessor();
            result = clone.template().send(target, processor);
        }

         
        cloned = false;
        useDefaultEndpoint = true;

        return result;
    }

    private void tryFlush() {
        lock.lock();
        try {
            flush();
        } catch (IOException e) {
            LOG.error("Unable to save record: {}", e.getMessage(), e);
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }
    }

    protected Map<String, Object> doCallJson(Map<String, Object> options) {
        JsonObject root = new JsonObject();

        if (rr != null) {
            List<JsonObject> list = new ArrayList<>();
            root.put("rests", list);

            for (RestRegistry.RestService rs : rr.listAllRestServices()) {
                JsonObject jo = new JsonObject();
                jo.put("url", rs.getUrl());
                jo.put("method", rs.getMethod());
                jo.put("contractFirst", rs.isContractFirst());
                jo.put("state", rs.getState());
                if (rs.getConsumes() != null) {
                    jo.put("consumes", rs.getConsumes());
                }
                if (rs.getProduces() != null) {
                    jo.put("produces", rs.getProduces());
                }
                if (rs.getInType() != null) {
                    jo.put("inType", rs.getInType());
                }
                if (rs.getOutType() != null) {
                    jo.put("outType", rs.getOutType());
                }
                if (rs.getDescription() != null) {
                    jo.put("description", rs.getDescription());
                }
                list.add(jo);
            }
        }

        return root;
    }

    private ProtobufSchema computeIfAbsent(Exchange exchange) {
        if (this.schema != null) {
            return this.schema;
        }

        ProtobufSchema answer = exchange.getProperty(SchemaHelper.CONTENT_SCHEMA, ProtobufSchema.class);

        if (answer == null && exchange.getProperties().containsKey(SchemaHelper.SCHEMA)) {
            String schemaJson = exchange.getProperty(SchemaHelper.SCHEMA, String.class);
            try {
                answer = ProtobufSchemaLoader.std.parse(schemaJson);
            } catch (IOException e) {
                throw new RuntimeException("Unable to parse Protobuf schema", e);
            }
        }

        if (answer == null) {
            String contentClass = SchemaHelper.resolveContentClass(exchange, this.contentClass);
            if (contentClass != null) {
                answer = this.schemes.computeIfAbsent(contentClass, t -> {
                    Resource res = PluginHelper.getResourceLoader(exchange.getContext())
                            .resolveResource("classpath:schemas/" + SchemaType.PROTOBUF.name().toLowerCase(Locale.US) +
                                             "/" + t + "." + SchemaType.PROTOBUF.type());

                    try {
                        if (res.exists()) {
                            try (InputStream is = res.getInputStream()) {
                                if (is != null) {
                                    return Protobuf.mapper().schemaLoader().load(is);
                                }
                            }
                        }
                    } catch (Exception e) {
                        throw new RuntimeException(
                                "Unable to load Protobuf schema for type: " + t + ", resource: " + res.getLocation(), e);
                    }

                    try {
                        return Protobuf.mapper().generateSchemaFor(Class.forName(contentClass));
                    } catch (JsonMappingException | ClassNotFoundException e) {
                        throw new RuntimeException(
                                "Unable to compute Protobuf schema for type: " + t, e);
                    }
                });
            }
        }

        if (answer != null) {
            this.schema = answer;
        }

        return answer;
    }

    private void onEventListener(final ChangeEvent<SourceRecord, SourceRecord> event) {
        final Exchange exchange = endpoint.createDbzExchange(this, event.value());

        try {
             
            getProcessor().process(exchange);
        } catch (Exception ex) {
            exchange.setException(ex);
        } finally {
             
            if (exchange.getException() != null) {
                getExceptionHandler().handleException("Error processing exchange", exchange,
                        exchange.getException());
            }
            releaseExchange(exchange, false);
        }
    }

    public static List<RestServiceDetails> parseRestService(
            JavaClassSource clazz, String fullyQualifiedFileName,
            boolean includeInlinedRouteBuilders) {

        List<MethodSource<JavaClassSource>> methods = findAllConfigureMethods(clazz, includeInlinedRouteBuilders);

        CamelJavaRestDslParserHelper parser = new CamelJavaRestDslParserHelper();
        List<RestServiceDetails> list = new ArrayList<>();
        for (MethodSource<JavaClassSource> configureMethod : methods) {
             
            List<RestServiceDetails> details = parser.parseRestService(clazz, fullyQualifiedFileName, configureMethod);
            list.addAll(details);
        }
         
        Collections.reverse(list);

        return list;
    }

    private void retainClusterView() {
        lock.lock();
        try {
            clusterView = clusterService.getView(namespace);
            clusterView.addEventListener(leadershipEventListener);
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }
    }

    public static Predicate contains(final Expression left, final Expression right) {
        return new BinaryPredicateSupport(left, right) {

            protected boolean matches(Exchange exchange, Object leftValue, Object rightValue) {
                if (leftValue == null && rightValue == null) {
                     
                    return true;
                } else if (leftValue == null || rightValue == null) {
                     
                    return false;
                }

                return ObjectHelper.typeCoerceContains(exchange.getContext().getTypeConverter(), leftValue, rightValue, false);
            }

            protected String getOperationText() {
                return "contains";
            }
        };
    }

    public boolean hasNext() {
        if (closed) {
            return false;
        }

        boolean hasNext = currentSearchHits.hasNext();
        if (!hasNext) {
            updateCurrentSearchHits();

            hasNext = currentSearchHits.hasNext();
        }

        return hasNext;
    }

    public static URI createURI(Exchange exchange, String url) throws URISyntaxException {
        URI uri = new URI(url);

         
        String queryString = (String) exchange.getIn().removeHeader(Exchange.REST_HTTP_QUERY);
         
         
        if (queryString == null) {
            queryString = exchange.getIn().getHeader(NettyHttpConstants.HTTP_RAW_QUERY, String.class);
        }
        if (queryString == null) {
            queryString = exchange.getIn().getHeader(NettyHttpConstants.HTTP_QUERY, String.class);
        }
        if (queryString == null) {
             
            queryString = uri.getRawQuery();
        }
        if (queryString != null) {
             
            queryString = UnsafeUriCharactersEncoder.encodeHttpURI(queryString);
            if (ObjectHelper.isEmpty(uri.getPath())) {
                 
                uri = new URI(url + "/");
            }

            uri = URISupport.createURIWithQuery(uri, queryString);
        }
        return uri;
    }

    public void performList(final Exchange exchange, AsyncCallback callback) {
        Message message = exchange.getMessage();
        Map<String, Object> headers = message.getHeaders();
        String subscribeChannel = (String) headers.getOrDefault(CONTROL_SUBSCRIBE_CHANNEL, configuration.getSubscribeChannel());
        try {
            String filters = dynamicRouterControlService.getSubscriptionsForChannel(subscribeChannel);
            message.setBody(filters, String.class);
        } catch (Exception e) {
            exchange.setException(e);
        } finally {
            callback.done(false);
        }
    }

    private String parseTopicName(String uri) {
         
        uri = uri.replaceFirst(scheme + "://", ":");

        uri = StringHelper.before(uri, "?", uri);
         

        int pos = uri.indexOf(':');
        if (pos != -1) {
            return uri.substring(pos + 1);
        } else {
            return null;
        }
    }

    protected void doInit() throws Exception {
        super.doInit();

        try {
            RestConfiguration config = CamelContextHelper.getRestConfiguration(getCamelContext(), "jetty");

             
            if (config.getComponentProperties() != null && !config.getComponentProperties().isEmpty()) {
                setProperties(this, config.getComponentProperties());
            }
        } catch (IllegalArgumentException e) {
             
             
             
        }
    }

private int jjMoveStringLiteralDfa1_0(long active0){
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(0, active0);
      return 1;
   }
   switch(curChar)
   {
      case 78:
         return jjMoveStringLiteralDfa2_0(active0, 0x8L);
      case 85:
         return jjMoveStringLiteralDfa2_0(active0, 0x4L);
      default :
         break;
   }
   return jjStartNfa_0(0, active0);
}

    private boolean dumpReceiveFiles(Map<Long, Pid> pids, int tail, Date limit) {
        Set<String> names = new HashSet<>();
        List<Row> rows = new ArrayList<>();
        for (Pid pid : pids.values()) {
            Queue<String> queue = pid.fifo;
            if (queue != null) {
                for (String l : queue) {
                    names.add(pid.name);
                    List<Row> parsed = parseReceiveLine(pid, l);
                    if (parsed != null && !parsed.isEmpty()) {
                        rows.addAll(parsed);
                    }
                }
                pid.fifo.clear();
            }
        }

         
        if (names.size() > 1) {
             
            final Map<String, Long> lastTimestamp = new HashMap<>();
            rows.sort((r1, r2) -> {
                long t1 = r1.timestamp;
                long t2 = r2.timestamp;
                if (t1 == 0) {
                    t1 = lastTimestamp.get(r1.name);
                }
                if (t1 == 0) {
                    t1 = lastTimestamp.get(r2.name);
                }
                if (t1 == 0 && t2 == 0) {
                    return 0;
                } else if (t1 == 0) {
                    return -1;
                } else if (t2 == 0) {
                    return 1;
                }
                lastTimestamp.put(r1.name, t1);
                lastTimestamp.put(r2.name, t2);
                return Long.compare(t1, t2);
            });
        }
        if (tail > 0) {
             
            int pos = rows.size() - tail;
            if (pos > 0) {
                rows = rows.subList(pos, rows.size());
            }
        }

        for (Row r : rows) {
            printDump(r.name, pids.size(), r, limit);
        }
        return true;
    }

    public void onDownloadComplete(String host, String file) {
        String prefix = resume ? "Resume downloading" : "Downloading";
        String msg = prefix + " from host: " + host + " file: " + file + " completed";
        if (transferredBytes > 0) {
            msg += " (size: " + StringHelper.humanReadableBytes(transferredBytes) + ")";
        }
        long taken = watch.taken();
        String time = TimeUtils.printDuration(taken, true);
        msg += " (took: " + time + ")";
        doLog(msg);
    }

    private String getSecretFromSource(
            String key, String subkey, String defaultValue, String version)
            throws JsonProcessingException {

         
        secrets.add(key);

        String returnValue = null;
        try {
            SecretVersionName secretVersionName
                    = SecretVersionName.of(projectId, key, ObjectHelper.isNotEmpty(version) ? version : "latest");
            AccessSecretVersionResponse response = client.accessSecretVersion(secretVersionName);
            if (ObjectHelper.isNotEmpty(response)) {
                returnValue = response.getPayload().getData().toStringUtf8();
            }
            if (ObjectHelper.isNotEmpty(subkey) && ObjectHelper.isNotEmpty(returnValue)) {
                ObjectMapper mapper = new ObjectMapper();
                JsonNode actualObj = mapper.readTree(returnValue);
                JsonNode field = actualObj.get(subkey);
                if (ObjectHelper.isNotEmpty(field)) {
                    returnValue = field.textValue();
                } else {
                    returnValue = null;
                }
            }
            if (ObjectHelper.isEmpty(returnValue)) {
                returnValue = defaultValue;
            }
        } catch (ApiException ex) {
            if (ObjectHelper.isNotEmpty(defaultValue)) {
                returnValue = defaultValue;
            } else {
                throw ex;
            }
        }
        return returnValue;
    }

    private void processSynchronously(final Exchange exchange, final ChannelHandlerContext ctx) {
        try {
            consumer.getProcessor().process(exchange);
            if (consumer.getConfiguration().isSync()) {
                sendResponse(ctx, exchange);
            }
        } catch (Exception e) {
            consumer.getExceptionHandler().handleException(e);
        } finally {
            consumer.doneUoW(exchange);
            consumer.releaseExchange(exchange, false);
        }
    }

    private List<HttpHost> parseHostAddresses(String ipsString, OpensearchConfiguration config) {
        if (ipsString == null || ipsString.isEmpty()) {
            return null;
        }
        List<String> addressesStr = Arrays.asList(ipsString.split(","));
        List<HttpHost> addressesTrAd = new ArrayList<>(addressesStr.size());
        for (String address : addressesStr) {
            String[] split = address.split(":");
            String hostname;
            if (split.length > 0) {
                hostname = split[0];
            } else {
                throw new IllegalArgumentException();
            }
            int port = split.length > 1 ? Integer.parseInt(split[1]) : OpensearchConstants.DEFAULT_PORT;
            addressesTrAd.add(new HttpHost(config.isEnableSSL() ? "HTTPS" : "HTTP", hostname, port));
        }
        return addressesTrAd;
    }

    public Pinecone getClient() {
        lock.lock();
        try {
            if (this.client == null) {
                this.client = this.configuration.getClient();
                if (this.client == null) {
                    this.client = createClient();
                }
            }
            return this.client;
        } finally {
            lock.unlock();
        }
    }

    protected String asTypeName(Class<?> classType) {
         
         
         
         
         
         
         
         

        String type;

        if (classType.isArray()) {
            type = classType.getComponentType().getName() + "[]";
        } else {
            type = classType.getName();
        }

        return type;
    }

    public WordCountGuardrail(int minWords, int maxWords) {
        if (minWords < 0) {
            throw new IllegalArgumentException("minWords cannot be negative");
        }
        if (maxWords <= 0) {
            throw new IllegalArgumentException("maxWords must be positive");
        }
        if (minWords > maxWords) {
            throw new IllegalArgumentException("minWords cannot exceed maxWords");
        }
        this.minWords = minWords;
        this.maxWords = maxWords;
    }

    protected void doStop() throws Exception {
        super.doStop();

        if (executor != null) {
            if (getEndpoint() != null && getEndpoint().getCamelContext() != null) {
                getEndpoint().getCamelContext().getExecutorServiceManager().shutdownNow(executor);
            } else {
                executor.shutdownNow();
            }
        }
        executor = null;
    }

    protected void doLog(Exchange exchange, String operation) throws GitAPIException {
        Iterable<RevCommit> revCommit = null;
        try {
            if (ObjectHelper.isNotEmpty(endpoint.getBranchName())) {
                git.checkout().setCreateBranch(false).setName(endpoint.getBranchName()).call();
            }
            revCommit = git.log().call();
        } catch (GitAPIException e) {
            LOG.error("There was an error in Git {} operation", operation);
            throw e;
        }
        updateExchange(exchange, revCommit);
    }

    public PollingConsumer createPollingConsumer() throws Exception {
        ObjectHelper.notNull(operations, PARAM_OPERATIONS);
        ObjectHelper.notNull(file, PARAM_FILE);

        if (maxMessagesPerPoll > 1) {
            throw new IllegalArgumentException(
                    "The option maxMessagesPerPoll is not supported for polling consumer (such as when using poll or pollEnrich EIP)");
        }

        if (LOG.isDebugEnabled()) {
            LOG.debug("Creating GenericFilePollingConsumer with queueSize: {} blockWhenFull: {} blockTimeout: {}",
                    getPollingConsumerQueueSize(), isPollingConsumerBlockWhenFull(),
                    getPollingConsumerBlockTimeout());
        }
        GenericFilePollingConsumer result = new GenericFilePollingConsumer(this);
         
         
        result.setBlockWhenFull(isPollingConsumerBlockWhenFull());
        result.setBlockTimeout(getPollingConsumerBlockTimeout());

        return result;
    }

    public Set<String> scan(CamelContext camelContext) {
        if (useRecovery) {
            LOG.trace("Scanning for exchanges to recover in {} context", camelContext.getName());
            Set<String> scanned = Collections.unmodifiableSet(replicatedPersistedCache.keySet());
            LOG.trace("Found {} keys for exchanges to recover in {} context", scanned.size(), camelContext.getName());
            return scanned;
        } else {
            LOG.warn(
                    "What for to run recovery scans in {} context while repository {} is running in non-recoverable aggregation repository mode?!",
                    camelContext.getName(), mapName);
            return Collections.emptySet();
        }
    }

    public void process(Exchange exchange) throws Exception {
        KinesisFirehose2Operations operation = determineOperation(exchange);
        if (ObjectHelper.isEmpty(operation)) {
            processSingleRecord(exchange);
        } else {
            switch (operation) {
                case sendBatchRecord:
                    sendBatchRecord(getClient(), exchange);
                    break;
                case createDeliveryStream:
                    createDeliveryStream(getClient(), exchange);
                    break;
                case deleteDeliveryStream:
                    deleteDeliveryStream(getClient(), exchange);
                    break;
                case updateDestination:
                    updateDestination(getClient(), exchange);
                    break;
                case describeDeliveryStream:
                    describeDeliveryStream(getClient(), exchange);
                    break;
                default:
                    throw new IllegalArgumentException("Unsupported operation");
            }
        }
    }

    private ProcessingResult autoCommitResultProcessing(
            KafkaConsumer camelKafkaConsumer, Exchange exchange, java.util.List<Exchange> exchanges) {
        ExceptionHandler exceptionHandler = camelKafkaConsumer.getExceptionHandler();
        CommitSynchronization commitSynchronization = new CommitSynchronization(exceptionHandler, exchanges.size());
        exchange.getExchangeExtension().addOnCompletion(commitSynchronization);
        try {
            processor.process(exchange);
        } catch (Exception e) {
            exchange.setException(e);
        }
        if (exchange.getException() != null) {
             
             
            if (configuration.isBreakOnFirstError()) {
                 
                Exchange firstExchange = exchanges.isEmpty() ? null : exchanges.get(0);
                if (firstExchange != null) {
                    Message message = firstExchange.getMessage();
                    String topic = (String) message.getHeader(KafkaConstants.TOPIC);
                    Integer partition = (Integer) message.getHeader(KafkaConstants.PARTITION);
                    Long offset = (Long) message.getHeader(KafkaConstants.OFFSET);
                    if (topic != null && partition != null && offset != null) {
                        return new ProcessingResult(true, true, topic, partition, offset);
                    }
                }
                 
                return new ProcessingResult(true, true);
            }
             
        }
        return ProcessingResult.newUnprocessed();
    }

    private static GenericFileExclusiveReadLockStrategy<File> newStrategyForIdempotentRename(
            Map<String, Object> params) {
        GenericFileExclusiveReadLockStrategy<File> strategy;
        FileIdempotentRenameRepositoryReadLockStrategy readLockStrategy
                = new FileIdempotentRenameRepositoryReadLockStrategy();
        Boolean readLockRemoveOnRollback = (Boolean) params.get("readLockRemoveOnRollback");
        if (readLockRemoveOnRollback != null) {
            readLockStrategy.setRemoveOnRollback(readLockRemoveOnRollback);
        }
        Boolean readLockRemoveOnCommit = (Boolean) params.get("readLockRemoveOnCommit");
        if (readLockRemoveOnCommit != null) {
            readLockStrategy.setRemoveOnCommit(readLockRemoveOnCommit);
        }
        IdempotentRepository repo = (IdempotentRepository) params.get("readLockIdempotentRepository");
        if (repo != null) {
            readLockStrategy.setIdempotentRepository(repo);
        }
        strategy = readLockStrategy;
        return strategy;
    }

    public List<Exchange> getExchanges(int limit, Predicate filter) {
        if (queueBrowseStrategy == null) {
            return Collections.emptyList();
        }
        String queue = getDestinationName();
        JmsOperations template = getConfiguration().createInOnlyTemplate(this, false, queue);
        List<Exchange> list = queueBrowseStrategy.browse(template, queue, this, limit);
        if (filter != null) {
            list = (List<Exchange>) list.stream().filter(filter).collect(Collectors.toList());
        }
        return list;
    }

    public Message toCamelMessage(InboundStreamHttpResponse response, Exchange exchange, NettyHttpConfiguration configuration) {
        LOG.trace("toCamelMessage: {}", response);

        NettyHttpMessage answer = new NettyHttpMessage(exchange.getContext(), null, null);
        answer.setExchange(exchange);
        if (configuration.isMapHeaders()) {
            populateCamelHeaders(response.getHttpResponse(), answer.getHeaders(), exchange, configuration);
        }

        answer.setBody(response.getInputStream());
        return answer;
    }

    private void validateRoles(String accessToken, Exchange exchange) throws Exception {
        try {
            Set<String> userRoles;

             
            if (policy.isUseTokenIntrospection() && policy.getTokenIntrospector() != null) {
                KeycloakTokenIntrospector.IntrospectionResult introspectionResult
                        = KeycloakSecurityHelper.introspectToken(accessToken, policy.getTokenIntrospector());

                 
                if (!introspectionResult.isActive()) {
                    throw new CamelAuthorizationException("Token is not active (may be revoked or expired)", exchange);
                }

                userRoles = KeycloakSecurityHelper.extractRolesFromIntrospection(
                        introspectionResult, policy.getRealm(), policy.getClientId());
            } else {
                 
                AccessToken token;
                if (ObjectHelper.isEmpty(policy.getPublicKey())) {
                    token = KeycloakSecurityHelper.parseAccessToken(accessToken);
                } else {
                    token = KeycloakSecurityHelper.parseAccessToken(accessToken, policy.getPublicKey());
                }
                userRoles = KeycloakSecurityHelper.extractRoles(token, policy.getRealm(), policy.getClientId());
            }

            boolean hasRequiredRoles = policy.isAllRolesRequired()
                    ? userRoles.containsAll(policy.getRequiredRolesAsList())
                    : policy.getRequiredRolesAsList().stream().anyMatch(userRoles::contains);

            if (!hasRequiredRoles) {
                String message = String.format("User does not have required roles. Required: %s, User has: %s",
                        policy.getRequiredRoles(), userRoles);
                LOG.debug(message);
                throw new CamelAuthorizationException(message, exchange);
            }

            LOG.debug("Role validation successful for user with roles: {}", userRoles);

        } catch (Exception e) {
            if (e instanceof CamelAuthorizationException) {
                throw e;
            }
            throw new CamelAuthorizationException("Failed to validate roles", exchange, e);
        }
    }

    public void setException(Throwable exception) {
        Objects.requireNonNull(exception, "exception must be not null");
        if (this.data != null) {
            throw new IllegalStateException("data has already been set");
        } else if (this.exception != null) {
            throw new IllegalStateException("an exception has already been set");
        }

        this.exception = exception;
        flushCycle();
    }

    public void configureAuthentication(
            AuthenticationConfig authenticationConfig,
            HttpServerConfigurationProperties properties) {

        String path
                = isNotEmpty(properties.getAuthenticationPath()) ? properties.getAuthenticationPath() : properties.getPath();
         
        if ("/".equals(path)) {
            path = "/*";
        }
        String realm = properties.getAuthenticationRealm() != null ? properties.getAuthenticationRealm() : null;

        AuthenticationConfigEntry entry = new AuthenticationConfigEntry();
        entry.setPath(path);
        entry.setAuthenticationHandlerFactory(new AuthenticationHandlerFactory() {
            @Override
            public <T extends AuthenticationProvider> AuthenticationHandler createAuthenticationHandler(
                    T authenticationProvider) {
                JWTAuth authProvider = (JWTAuth) authenticationProvider;
                return JWTAuthHandler.create(authProvider, realm);
            }
        });
        entry.setAuthenticationProviderFactory(vertx -> JWTAuth.create(
                vertx,
                new JWTAuthOptions(
                        new JsonObject().put("keyStore", new JsonObject()
                                .put("type", properties.getJwtKeystoreType())
                                .put("path", properties.getJwtKeystorePath())
                                .put("password", properties.getJwtKeystorePassword())))));

        authenticationConfig.getEntries().add(entry);
        authenticationConfig.setEnabled(true);
    }

    protected void doStop() throws Exception {
        super.doStop();

        LOG.debug("Stopping Kubernetes Nodes Consumer");
        if (executor != null) {
            KubernetesHelper.close(nodesWatcher, nodesWatcher::getWatch);

            if (getEndpoint() != null && getEndpoint().getCamelContext() != null) {
                getEndpoint().getCamelContext().getExecutorServiceManager().shutdownNow(executor);
            } else {
                executor.shutdownNow();
            }
        }
        executor = null;
    }

    protected void doStart() throws Exception {
        super.doStart();
        try {
            plc4XEndpoint.setupConnection();
            if (plc4XEndpoint.isConnected() && !plc4XEndpoint.canWrite()) {
                throw new PlcException("This connection (" + plc4XEndpoint.getUri() + ") doesn't support writing.");
            }
        } catch (PlcConnectionException e) {
            if (log.isTraceEnabled()) {
                log.error("Connection setup failed, stopping producer", e);
            } else {
                log.error("Connection setup failed, stopping producer");
            }
            doStop();
        }
    }

    protected String predict(Exchange exchange, Audio audio) {
        Model model = exchange.getContext().getRegistry().lookupByNameAndType(modelName, Model.class);
        @SuppressWarnings("unchecked")
        Translator<Audio, String> translator
                = exchange.getContext().getRegistry().lookupByNameAndType(translatorName, Translator.class);

        exchange.getIn().setHeader(DJLConstants.INPUT, audio);
        try (Predictor<Audio, String> predictor = model.newPredictor(translator)) {
            return predictor.predict(audio);
        } catch (TranslateException e) {
            throw new RuntimeCamelException("Could not process input or output", e);
        }
    }

    private static GenericFileExclusiveReadLockStrategy<File> newStrategyForIdempotent(
            Map<String, Object> params) {
        GenericFileExclusiveReadLockStrategy<File> strategy;
        FileIdempotentRepositoryReadLockStrategy readLockStrategy = new FileIdempotentRepositoryReadLockStrategy();
        Boolean readLockRemoveOnRollback = (Boolean) params.get("readLockRemoveOnRollback");
        if (readLockRemoveOnRollback != null) {
            readLockStrategy.setRemoveOnRollback(readLockRemoveOnRollback);
        }
        Boolean readLockRemoveOnCommit = (Boolean) params.get("readLockRemoveOnCommit");
        if (readLockRemoveOnCommit != null) {
            readLockStrategy.setRemoveOnCommit(readLockRemoveOnCommit);
        }
        IdempotentRepository repo = (IdempotentRepository) params.get("readLockIdempotentRepository");
        if (repo != null) {
            readLockStrategy.setIdempotentRepository(repo);
        }
        Integer readLockIdempotentReleaseDelay = (Integer) params.get("readLockIdempotentReleaseDelay");
        if (readLockIdempotentReleaseDelay != null) {
            readLockStrategy.setReadLockIdempotentReleaseDelay(readLockIdempotentReleaseDelay);
        }
        Boolean readLockIdempotentReleaseAsync = (Boolean) params.get("readLockIdempotentReleaseAsync");
        if (readLockIdempotentReleaseAsync != null) {
            readLockStrategy.setReadLockIdempotentReleaseAsync(readLockIdempotentReleaseAsync);
        }
        Integer readLockIdempotentReleaseAsyncPoolSize = (Integer) params.get("readLockIdempotentReleaseAsyncPoolSize");
        if (readLockIdempotentReleaseAsyncPoolSize != null) {
            readLockStrategy.setReadLockIdempotentReleaseAsyncPoolSize(readLockIdempotentReleaseAsyncPoolSize);
        }
        ScheduledExecutorService readLockIdempotentReleaseExecutorService
                = (ScheduledExecutorService) params.get("readLockIdempotentReleaseExecutorService");
        if (readLockIdempotentReleaseExecutorService != null) {
            readLockStrategy.setReadLockIdempotentReleaseExecutorService(readLockIdempotentReleaseExecutorService);
        }
        strategy = readLockStrategy;
        return strategy;
    }

    public void beforeTracingEvent(Span span, Exchange exchange, Endpoint endpoint) {
        super.beforeTracingEvent(span, exchange, endpoint);
        span.setTag(TagConstants.DB_SYSTEM, CASSANDRA_DB_TYPE);
        URI uri = URI.create(endpoint.getEndpointUri());
        if (uri.getPath() != null && !uri.getPath().isEmpty()) {
             
            span.setTag(TagConstants.DB_NAME, uri.getPath().substring(1));
        }

        String cql = exchange.getIn().getHeader(CAMEL_CQL_QUERY, String.class);
        if (cql != null) {
            span.setTag(TagConstants.DB_STATEMENT, cql);
        } else {
            Map<String, String> queryParameters = toQueryParameters(endpoint.getEndpointUri());
            if (queryParameters.containsKey("cql")) {
                span.setTag(TagConstants.DB_STATEMENT, queryParameters.get("cql"));
            }
        }
    }

    private void delayOrScheduleLockRelease(Runnable r) throws InterruptedException {
        if (readLockIdempotentReleaseDelay > 0 && readLockIdempotentReleaseExecutorService != null) {
            LOG.debug("Scheduling read lock release task to run asynchronous delayed after {} millis",
                    readLockIdempotentReleaseDelay);
            readLockIdempotentReleaseExecutorService.schedule(r, readLockIdempotentReleaseDelay, TimeUnit.MILLISECONDS);
        } else if (readLockIdempotentReleaseDelay > 0) {
            LOG.debug("Delaying read lock release task {} millis", readLockIdempotentReleaseDelay);
            Thread.sleep(readLockIdempotentReleaseDelay);
            r.run();
        } else {
            r.run();
        }
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.mongodb.ReadPreference.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.mongodb.gridfs.GridFsConverter.toReadPreference((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, com.mongodb.WriteConcern.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.mongodb.gridfs.GridFsConverter.toWriteConcern((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    protected JsonObject doCallJson(Map<String, Object> options) {
        JsonObject root = new JsonObject();
        if (propertiesFunction != null) {
            if (propertiesFunction.isUseDefaultInstance()) {
                root.put("login", "Default Instance");
            } else {
                root.put("login", "Service Account Key File");
            }
            GcpVaultConfiguration gcp = getCamelContext().getVaultConfiguration().getGcpVaultConfiguration();
            if (gcp != null) {
                root.put("refreshEnabled", gcp.isRefreshEnabled());
                root.put("refreshPeriod", gcp.getRefreshPeriod());
            }
            if (secretsRefreshTask != null) {
                Instant last = secretsRefreshTask.getLastCheckTime();
                if (last != null) {
                    long timestamp = last.toEpochMilli();
                    root.put("lastCheckTimestamp", timestamp);
                    root.put("lastCheckAge", TimeUtils.printSince(timestamp));
                }
                last = secretsRefreshTask.getLastReloadTime();
                if (last != null) {
                    long timestamp = last.toEpochMilli();
                    root.put("lastReloadTimestamp", timestamp);
                    root.put("lastReloadAge", TimeUtils.printSince(timestamp));
                }
            }
            JsonArray arr = new JsonArray();
            root.put("secrets", arr);

            List<String> sorted = new ArrayList<>(propertiesFunction.getSecrets());
            Collections.sort(sorted);

            for (String sec : sorted) {
                JsonObject jo = new JsonObject();
                jo.put("name", sec);
                Instant last = secretsRefreshTask != null ? secretsRefreshTask.getUpdates().get(sec) : null;
                if (last != null) {
                    long timestamp = last.toEpochMilli();
                    jo.put("timestamp", timestamp);
                    jo.put("age", TimeUtils.printSince(timestamp));
                }
                arr.add(jo);
            }
        }
        return root;
    }

    public GenericFileProcessStrategy<FileIdBothDirectoryInformation> createGenericFileProcessStrategy(
            CamelContext context, Map<String, Object> params) {

         
         
        Expression moveExpression = (Expression) params.get("move");
        Expression moveFailedExpression = (Expression) params.get("moveFailed");
        Expression preMoveExpression = (Expression) params.get("preMove");
        boolean isNoop = params.get("noop") != null;
        boolean isDelete = params.get("delete") != null;
        boolean isMove = moveExpression != null || preMoveExpression != null || moveFailedExpression != null;

        if (isDelete) {
            GenericFileDeleteProcessStrategy<FileIdBothDirectoryInformation> strategy
                    = new GenericFileDeleteProcessStrategy<>();
            strategy.setExclusiveReadLockStrategy(getExclusiveReadLockStrategy(params));
            if (preMoveExpression != null) {
                GenericFileExpressionRenamer<FileIdBothDirectoryInformation> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(preMoveExpression);
                strategy.setBeginRenamer(renamer);
            }
            if (moveFailedExpression != null) {
                GenericFileExpressionRenamer<FileIdBothDirectoryInformation> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(moveFailedExpression);
                strategy.setFailureRenamer(renamer);
            }
            return strategy;
        } else if (isMove || isNoop) {
            GenericFileRenameProcessStrategy<FileIdBothDirectoryInformation> strategy
                    = new GenericFileRenameProcessStrategy<>();
            strategy.setExclusiveReadLockStrategy(getExclusiveReadLockStrategy(params));
            if (!isNoop && moveExpression != null) {
                 
                GenericFileExpressionRenamer<FileIdBothDirectoryInformation> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(moveExpression);
                strategy.setCommitRenamer(renamer);
            }
             
            if (moveFailedExpression != null) {
                GenericFileExpressionRenamer<FileIdBothDirectoryInformation> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(moveFailedExpression);
                strategy.setFailureRenamer(renamer);
            }
             
            if (preMoveExpression != null) {
                GenericFileExpressionRenamer<FileIdBothDirectoryInformation> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(preMoveExpression);
                strategy.setBeginRenamer(renamer);
            }
            return strategy;
        } else {
             
            GenericFileNoOpProcessStrategy<FileIdBothDirectoryInformation> strategy = new GenericFileNoOpProcessStrategy<>();
            strategy.setExclusiveReadLockStrategy(getExclusiveReadLockStrategy(params));
            return strategy;
        }
    }

    public static Expression fileExtensionExpression() {
        return new ExpressionAdapter() {
            @Override
            public Object evaluate(Exchange exchange) {
                String name = exchange.getIn().getHeader(Exchange.FILE_NAME, String.class);
                return FileUtil.onlyExt(name);
            }

            @Override
            public String toString() {
                return "file:ext";
            }
        };
    }

    public RestDefinition apiDocs(Boolean apiDocs) {
        if (getVerbs().isEmpty()) {
            this.apiDocs = apiDocs != null ? apiDocs.toString() : null;
        } else {
             
            VerbDefinition verb = getVerbs().get(getVerbs().size() - 1);
            verb.setApiDocs(apiDocs != null ? apiDocs.toString() : null);
        }

        return this;
    }

    public void onPutIfAbsent(Message message) {
        final BasicCache<Object, Object> cache = getCache(message);
        final Object key = message.getHeader(InfinispanConstants.KEY, configuration::getKey);
        final Object value = message.getHeader(InfinispanConstants.VALUE, configuration::getValue);
        final Object result;

        if (hasLifespan(message)) {
            long lifespan = message.getHeader(InfinispanConstants.LIFESPAN_TIME, long.class);
            TimeUnit timeUnit = message.getHeader(InfinispanConstants.LIFESPAN_TIME_UNIT, TimeUnit.class);

            if (hasMaxIdleTime(message)) {
                long maxIdle = message.getHeader(InfinispanConstants.MAX_IDLE_TIME, long.class);
                TimeUnit maxIdleTimeUnit = message.getHeader(InfinispanConstants.MAX_IDLE_TIME_UNIT, TimeUnit.class);

                result = cache.putIfAbsent(key, value, lifespan, timeUnit, maxIdle, maxIdleTimeUnit);
            } else {
                result = cache.putIfAbsent(key, value, lifespan, timeUnit);
            }
        } else {
            result = cache.putIfAbsent(key, value);
        }

        setResult(message, result);
    }

    protected Object doInvokeMethod(Map<String, Object> properties) throws RuntimeCamelException {
        AbstractGoogleClientRequest request = (AbstractGoogleClientRequest) super.doInvokeMethod(properties);
        try {
            BeanIntrospection beanIntrospection
                    = PluginHelper.getBeanIntrospection(getEndpoint().getCamelContext());
            for (Entry<String, Object> p : properties.entrySet()) {
                beanIntrospection.setProperty(getEndpoint().getCamelContext(), request, p.getKey(), p.getValue());
            }
            return request.execute();
        } catch (Exception e) {
            throw new RuntimeCamelException(e);
        }
    }

    public void updateRouteConfigurationsToCamelContext(CamelContext context) throws Exception {
        setCamelContext(context);
        routeConfigurationCollection.setCamelContext(context);
        if (initializedConfiguration.compareAndSet(false, true)) {
            configuration();
        }
        List<RouteConfigurationDefinition> list = getRouteConfigurationCollection().getRouteConfigurations();
        if (!list.isEmpty()) {
             
            for (RouteConfigurationDefinition def : list) {
                context.getCamelContextExtension().getContextPlugin(Model.class).removeRouteConfiguration(def);
            }
            populateRoutesConfiguration();
        }
    }

    private OperationResult synchronouslySetData(ProductionContext ctx) throws Exception {

        SetDataOperation setData = new SetDataOperation(ctx.connection, ctx.node, ctx.payload);
        setData.setVersion(ctx.version);

        OperationResult result = setData.get();

        if (!result.isOk() && configuration.isCreate() && result.failedDueTo(Code.NONODE)) {
            LOG.warn("Node '{}' did not exist, creating it.", ctx.node);
            result = createNode(ctx);
        }
        return result;
    }

    private Function<Exchange, Object> updateEdge() {
        return exchange -> {
            try {
                ArangoEdgeCollection edgeCollection = calculateEdgeCollection();
                String key = (String) exchange.getMessage().getHeader(ARANGO_KEY);
                Object edgeDocument = exchange.getMessage().getMandatoryBody();
                return edgeCollection.updateEdge(key, edgeDocument);
            } catch (InvalidPayloadException e) {
                throw new RuntimeCamelException(INVALID_PAYLOAD_MESSAGE, e);
            }
        };
    }

    private AlgorithmParameterSpec getDefaultParameterSpec(String algorithm) {
         
        try {
            switch (algorithm) {
                case "DILITHIUM":
                    return org.bouncycastle.pqc.jcajce.spec.DilithiumParameterSpec.dilithium2;
                case "MLDSA":
                case "SLHDSA":
                     
                    return null;
                case "FALCON":
                    return org.bouncycastle.pqc.jcajce.spec.FalconParameterSpec.falcon_512;
                case "SPHINCSPLUS":
                    return org.bouncycastle.pqc.jcajce.spec.SPHINCSPlusParameterSpec.sha2_128s;
                case "XMSS":
                    return new org.bouncycastle.pqc.jcajce.spec.XMSSParameterSpec(
                            10,
                            org.bouncycastle.pqc.jcajce.spec.XMSSParameterSpec.SHA256);
                case "XMSSMT":
                    return org.bouncycastle.pqc.jcajce.spec.XMSSMTParameterSpec.XMSSMT_SHA2_20d2_256;
                case "LMS":
                case "HSS":
                    return new org.bouncycastle.pqc.jcajce.spec.LMSKeyGenParameterSpec(
                            org.bouncycastle.pqc.crypto.lms.LMSigParameters.lms_sha256_n32_h10,
                            org.bouncycastle.pqc.crypto.lms.LMOtsParameters.sha256_n32_w4);
                case "MLKEM":
                case "KYBER":
                     
                    return null;
                case "NTRU":
                    return org.bouncycastle.pqc.jcajce.spec.NTRUParameterSpec.ntruhps2048509;
                case "NTRULPRime":
                    return org.bouncycastle.pqc.jcajce.spec.NTRULPRimeParameterSpec.ntrulpr653;
                case "SNTRUPrime":
                    return org.bouncycastle.pqc.jcajce.spec.SNTRUPrimeParameterSpec.sntrup761;
                case "SABER":
                    return org.bouncycastle.pqc.jcajce.spec.SABERParameterSpec.lightsaberkem128r3;
                case "FRODO":
                    return org.bouncycastle.pqc.jcajce.spec.FrodoParameterSpec.frodokem640aes;
                case "BIKE":
                    return org.bouncycastle.pqc.jcajce.spec.BIKEParameterSpec.bike128;
                case "HQC":
                    return org.bouncycastle.pqc.jcajce.spec.HQCParameterSpec.hqc128;
                case "CMCE":
                    return org.bouncycastle.pqc.jcajce.spec.CMCEParameterSpec.mceliece348864;
                default:
                    return null;
            }
        } catch (Exception e) {
            LOG.warn("Failed to create default parameter spec for algorithm: {}", algorithm, e);
            return null;
        }
    }

    private static void parseMessageDispositionNotificationReportEntity(
            HttpMessage message, InputStream is, AS2SessionInputBuffer inBuffer, String boundary, String charsetName,
            String contentTransferEncoding)
            throws HttpException {
        DispositionNotificationMultipartReportEntity dispositionNotificationMultipartReportEntity = null;

        ObjectHelper.notNull(message, "message");
        ObjectHelper.notNull(inBuffer, "inBuffer");
        ObjectHelper.notNull(boundary, "boundary");
        ObjectHelper.notNull(charsetName, "charsetName");
        HttpEntity entity = ObjectHelper.notNull(EntityUtils.getMessageEntity(message), "message entity");

        if (entity instanceof DispositionNotificationMultipartReportEntity) {
             
            return;
        }

        Args.check(entity.isStreaming(), "Message entity can not be parsed: entity is not streaming");

        try {

            dispositionNotificationMultipartReportEntity
                    = parseMultipartReportEntityBody(inBuffer, is, boundary, charsetName, contentTransferEncoding);

            EntityUtils.setMessageEntity(message, dispositionNotificationMultipartReportEntity);

        } catch (Exception e) {
            throw new HttpException("Failed to parse entity content", e);
        }
    }

    public void transform(Message message, DataType fromType, DataType toType) {
        final Map<String, Object> headers = message.getHeaders();

        CloudEvent cloudEvent = CloudEvents.v1_0;
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_ID, message.getExchange().getExchangeId());
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_VERSION, cloudEvent.version());
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TYPE, "org.apache.camel.event.azure.eventhubs.consume");

        if (message.getHeaders().containsKey(EventHubsConstants.PARTITION_ID)) {
            headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SOURCE,
                    "azure.eventhubs." + message.getHeader(EventHubsConstants.PARTITION_ID, String.class));
        }

        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SUBJECT, message.getHeader(EventHubsConstants.SEQUENCE_NUMBER, Long.class));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TIME, cloudEvent.getEventTime(message.getExchange()));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_CONTENT_TYPE, CloudEvent.APPLICATION_OCTET_STREAM_MIME_TYPE);
    }

    protected int poll() throws Exception {
        Exchange exchange = receive(getEndpoint().getReadTimeout());
        if (exchange != null) {
            getProcessor().process(exchange);
            return 1;
        } else {
            return 0;
        }
    }

    protected boolean acceptResource(Resource resource) {
        String loc = resource.getLocation();
        if (loc == null) {
            return false;
        }
        if (loc.endsWith("default-registry")) {
             
            return false;
        }

        return true;
    }

    public static List<FieldInfo> fields(IndexView view, ClassInfo type, Predicate<FieldInfo> filter) {
        List<FieldInfo> answer = new ArrayList<>();

        for (ClassInfo current = type; current != null;) {
            for (FieldInfo fieldInfo : current.fields()) {
                if (filter.test(fieldInfo)) {
                    answer.add(fieldInfo);
                }
            }

            Type superType = current.superClassType();
            if (superType == null) {
                break;
            }

            current = view.getClassByName(superType.name());
        }

        return answer;
    }

    public void process(Exchange exchange) {
        var context = exchange.getContext();
        var msg = exchange.getMessage();

        logRequestHeaders(procName, msg);

         
         
        var oauth = findOAuth(context).orElseGet(() -> {
            var factory = OAuthFactory.lookupFactory(context);
            return factory.createOAuth();
        });

         
         
        var session = oauth.getOrCreateSession(exchange);

         
         
        if (session.getUserProfile().isPresent()) {
            var userProfile = session.removeUserProfile().orElseThrow();
            try {
                userProfile = authenticateExistingUserProfile(oauth, userProfile);
                session.putUserProfile(userProfile);
                return;
            } catch (OAuthException ex) {
                log.error("Failed to authenticate: {}", userProfile.subject(), ex);
            }
        }

         
         
        var clientId = getRequiredProperty(exchange.getContext(), CAMEL_OAUTH_CLIENT_ID);
        var clientSecret = getRequiredProperty(exchange.getContext(), CAMEL_OAUTH_CLIENT_SECRET);

        var userProfile = oauth.authenticate(new ClientCredentials()
                .setClientSecret(clientSecret)
                .setClientId(clientId));

        session.putUserProfile(userProfile);
        log.info("Authenticated {}", userProfile.subject());
        userProfile.logDetails();

         
         
        var accessToken = userProfile.accessToken().orElseThrow(() -> new OAuthException("No access_token"));
        msg.setHeader("Authorization", "Bearer " + accessToken);
    }

    private String getUri(Row r) {
        String u = r.uri;
        if (shortUri) {
            int pos = u.indexOf('?');
            if (pos > 0) {
                u = u.substring(0, pos);
            }
        }
        return u;
    }

    public void process(Exchange exchange) throws Exception {
        Hits hits;

        String phrase = exchange.getIn().getHeader(LuceneConstants.HEADER_QUERY, String.class);
        String returnLuceneDocs = exchange.getIn().getHeader(LuceneConstants.HEADER_RETURN_LUCENE_DOCS, String.class);
        boolean isReturnLuceneDocs = returnLuceneDocs != null && returnLuceneDocs.equalsIgnoreCase("true");

        if (phrase != null) {
            searcher = new LuceneSearcher();
            searcher.open(indexDirectory, analyzer);
            hits = searcher.search(phrase, maxNumberOfHits, totalHitsThreshold, isReturnLuceneDocs);
        } else {
            throw new IllegalArgumentException("SearchPhrase for LuceneQueryProcessor not set. Set the Header value: QUERY");
        }

        exchange.getIn().setBody(hits);
    }

    protected RouteConfigurationDefinition createRouteConfiguration(String id) {
        RouteConfigurationDefinition config = new RouteConfigurationDefinition();
        if (id != null) {
            config.setId(id);
        }
        if (resource != null) {
            config.setResource(resource);
        }
        CamelContextAware.trySetCamelContext(config, camelContext);
        return config;
    }

    public static BoxAPIConnection createAppEnterpriseAuthenticatedConnection(BoxConfiguration configuration) {
         
        JWTEncryptionPreferences encryptionPref = new JWTEncryptionPreferences();
        encryptionPref.setPublicKeyID(configuration.getPublicKeyId());

        try {
            encryptionPref.setPrivateKey(new String(Files.readAllBytes(Paths.get(configuration.getPrivateKeyFile()))));
        } catch (Exception e) {
            throw new RuntimeCamelException("Box API connection failed: could not read privateKeyFile", e);
        }

        encryptionPref.setPrivateKeyPassword(configuration.getPrivateKeyPassword());
        encryptionPref.setEncryptionAlgorithm(configuration.getEncryptionAlgorithm());

        IAccessTokenCache accessTokenCache = configuration.getAccessTokenCache();
        if (accessTokenCache == null) {
            accessTokenCache = new InMemoryLRUAccessTokenCache(configuration.getMaxCacheEntries());
        }

        try {
            return BoxDeveloperEditionAPIConnection.getAppEnterpriseConnection(configuration.getEnterpriseId(),
                    configuration.getClientId(), configuration.getClientSecret(), encryptionPref, accessTokenCache);
        } catch (BoxAPIException e) {
            throw new RuntimeCamelException(
                    String.format("Box API connection failed: API returned the error code %d%n%n%s",
                            e.getResponseCode(), e.getResponse()),
                    e);
        }

    }

    public <T> void read(
            final Edm edm, final String resourcePath, final Map<String, String> queryParams,
            final Map<String, String> endpointHttpHeaders,
            final Olingo2ResponseHandler<T> responseHandler) {

        final UriInfoWithType uriInfo = parseUri(edm, resourcePath, queryParams);

        execute(new HttpGet(createUri(resourcePath, encodeQueryParams(queryParams))), getResourceContentType(uriInfo),
                endpointHttpHeaders,
                new AbstractFutureCallback<T>(responseHandler) {

                    @Override
                    public void onCompleted(HttpResponse result) throws IOException {
                        readContent(uriInfo, headersToMap(result.getAllHeaders()),
                                result.getEntity() != null ? result.getEntity().getContent() : null, responseHandler);
                    }

                });
    }

    public Exchange add(CamelContext camelContext, String key, Exchange exchange) {
        if (optimistic) {
            throw new UnsupportedOperationException();
        }
        LOG.trace("Adding an Exchange with ID {} for key {} in a thread-safe manner.", exchange.getExchangeId(), key);
        Lock l = hazelcastInstance.getCPSubsystem().getLock(mapName);
        try {
            l.lock();
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(exchange, true, allowSerializedHeaders);
            DefaultExchangeHolder oldHolder = cache.put(key, newHolder);
            return unmarshallExchange(camelContext, oldHolder);
        } finally {
            LOG.trace("Added an Exchange with ID {} for key {} in a thread-safe manner.", exchange.getExchangeId(), key);
            l.unlock();
        }
    }

    private ProcessingResult autoCommitResultProcessing(
            KafkaConsumer camelKafkaConsumer, Exchange exchange, java.util.List<Exchange> exchanges) {
        ExceptionHandler exceptionHandler = camelKafkaConsumer.getExceptionHandler();
        CommitSynchronization commitSynchronization = new CommitSynchronization(exceptionHandler, exchanges.size());
        exchange.getExchangeExtension().addOnCompletion(commitSynchronization);
        try {
            processor.process(exchange);
        } catch (Exception e) {
            exchange.setException(e);
        }
        if (exchange.getException() != null) {
             
             
            if (configuration.isBreakOnFirstError()) {
                 
                Exchange firstExchange = exchanges.isEmpty() ? null : exchanges.get(0);
                if (firstExchange != null) {
                    Message message = firstExchange.getMessage();
                    String topic = (String) message.getHeader(KafkaConstants.TOPIC);
                    Integer partition = (Integer) message.getHeader(KafkaConstants.PARTITION);
                    Long offset = (Long) message.getHeader(KafkaConstants.OFFSET);
                    if (topic != null && partition != null && offset != null) {
                        return new ProcessingResult(true, true, topic, partition, offset);
                    }
                }
                 
                return new ProcessingResult(true, true);
            }
             
        }
        return ProcessingResult.newUnprocessed();
    }

    private KMS2Operations determineOperation(Exchange exchange) {
        KMS2Operations operation = exchange.getIn().getHeader(KMS2Constants.OPERATION, KMS2Operations.class);
        if (operation == null) {
            operation = getConfiguration().getOperation();
        }

        if (ObjectHelper.isEmpty(operation)) {
            throw new IllegalArgumentException("Operation must be specified");
        }
        return operation;
    }

        protected boolean setPropertyOnComponent(
                Component component,
                String name,
                Object value) {
            switch (name) {
            case "brokerURL": ((ActiveMQComponent) component).setBrokerURL((java.lang.String) value); return true;
            case "clientId": getOrCreateConfiguration((ActiveMQComponent) component).setClientId((java.lang.String) value); return true;
            case "connectionFactory": getOrCreateConfiguration((ActiveMQComponent) component).setConnectionFactory((jakarta.jms.ConnectionFactory) value); return true;
            case "disableReplyTo": getOrCreateConfiguration((ActiveMQComponent) component).setDisableReplyTo((boolean) value); return true;
            case "durableSubscriptionName": getOrCreateConfiguration((ActiveMQComponent) component).setDurableSubscriptionName((java.lang.String) value); return true;
            case "embedded": ((ActiveMQComponent) component).setEmbedded((boolean) value); return true;
            case "jmsMessageType": getOrCreateConfiguration((ActiveMQComponent) component).setJmsMessageType((org.apache.camel.component.jms.JmsMessageType) value); return true;
            case "replyTo": getOrCreateConfiguration((ActiveMQComponent) component).setReplyTo((java.lang.String) value); return true;
            case "testConnectionOnStartup": getOrCreateConfiguration((ActiveMQComponent) component).setTestConnectionOnStartup((boolean) value); return true;
            case "usePooledConnection": ((ActiveMQComponent) component).setUsePooledConnection((boolean) value); return true;
            case "useSingleConnection": ((ActiveMQComponent) component).setUseSingleConnection((boolean) value); return true;
            case "acknowledgementModeName": getOrCreateConfiguration((ActiveMQComponent) component).setAcknowledgementModeName((java.lang.String) value); return true;
            case "artemisConsumerPriority": getOrCreateConfiguration((ActiveMQComponent) component).setArtemisConsumerPriority((int) value); return true;
            case "asyncConsumer": getOrCreateConfiguration((ActiveMQComponent) component).setAsyncConsumer((boolean) value); return true;
            case "autoStartup": getOrCreateConfiguration((ActiveMQComponent) component).setAutoStartup((boolean) value); return true;
            case "cacheLevel": getOrCreateConfiguration((ActiveMQComponent) component).setCacheLevel((int) value); return true;
            case "cacheLevelName": getOrCreateConfiguration((ActiveMQComponent) component).setCacheLevelName((java.lang.String) value); return true;
            case "concurrentConsumers": getOrCreateConfiguration((ActiveMQComponent) component).setConcurrentConsumers((int) value); return true;
            case "maxConcurrentConsumers": getOrCreateConfiguration((ActiveMQComponent) component).setMaxConcurrentConsumers((int) value); return true;
            case "replyToDeliveryPersistent": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToDeliveryPersistent((boolean) value); return true;
            case "selector": getOrCreateConfiguration((ActiveMQComponent) component).setSelector((java.lang.String) value); return true;
            case "subscriptionDurable": getOrCreateConfiguration((ActiveMQComponent) component).setSubscriptionDurable((boolean) value); return true;
            case "subscriptionName": getOrCreateConfiguration((ActiveMQComponent) component).setSubscriptionName((java.lang.String) value); return true;
            case "subscriptionShared": getOrCreateConfiguration((ActiveMQComponent) component).setSubscriptionShared((boolean) value); return true;
            case "acceptMessagesWhileStopping": getOrCreateConfiguration((ActiveMQComponent) component).setAcceptMessagesWhileStopping((boolean) value); return true;
            case "allowReplyManagerQuickStop": getOrCreateConfiguration((ActiveMQComponent) component).setAllowReplyManagerQuickStop((boolean) value); return true;
            case "consumerType": getOrCreateConfiguration((ActiveMQComponent) component).setConsumerType((org.apache.camel.component.jms.ConsumerType) value); return true;
            case "defaultTaskExecutorType": getOrCreateConfiguration((ActiveMQComponent) component).setDefaultTaskExecutorType((org.apache.camel.component.jms.DefaultTaskExecutorType) value); return true;
            case "eagerLoadingOfProperties": getOrCreateConfiguration((ActiveMQComponent) component).setEagerLoadingOfProperties((boolean) value); return true;
            case "eagerPoisonBody": getOrCreateConfiguration((ActiveMQComponent) component).setEagerPoisonBody((java.lang.String) value); return true;
            case "exposeListenerSession": getOrCreateConfiguration((ActiveMQComponent) component).setExposeListenerSession((boolean) value); return true;
            case "replyToConsumerType": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToConsumerType((org.apache.camel.component.jms.ConsumerType) value); return true;
            case "replyToSameDestinationAllowed": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToSameDestinationAllowed((boolean) value); return true;
            case "taskExecutor": getOrCreateConfiguration((ActiveMQComponent) component).setTaskExecutor((org.springframework.core.task.TaskExecutor) value); return true;
            case "deliveryDelay": getOrCreateConfiguration((ActiveMQComponent) component).setDeliveryDelay((long) value); return true;
            case "deliveryMode": getOrCreateConfiguration((ActiveMQComponent) component).setDeliveryMode((java.lang.Integer) value); return true;
            case "deliveryPersistent": getOrCreateConfiguration((ActiveMQComponent) component).setDeliveryPersistent((boolean) value); return true;
            case "explicitQosEnabled": getOrCreateConfiguration((ActiveMQComponent) component).setExplicitQosEnabled((java.lang.Boolean) value); return true;
            case "formatDateHeadersToIso8601": getOrCreateConfiguration((ActiveMQComponent) component).setFormatDateHeadersToIso8601((boolean) value); return true;
            case "lazyStartProducer": ((ActiveMQComponent) component).setLazyStartProducer((boolean) value); return true;
            case "preserveMessageQos": getOrCreateConfiguration((ActiveMQComponent) component).setPreserveMessageQos((boolean) value); return true;
            case "priority": getOrCreateConfiguration((ActiveMQComponent) component).setPriority((int) value); return true;
            case "replyToConcurrentConsumers": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToConcurrentConsumers((int) value); return true;
            case "replyToMaxConcurrentConsumers": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToMaxConcurrentConsumers((int) value); return true;
            case "replyToOnTimeoutMaxConcurrentConsumers": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToOnTimeoutMaxConcurrentConsumers((int) value); return true;
            case "replyToOverride": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToOverride((java.lang.String) value); return true;
            case "replyToType": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToType((org.apache.camel.component.jms.ReplyToType) value); return true;
            case "requestTimeout": getOrCreateConfiguration((ActiveMQComponent) component).setRequestTimeout((long) value); return true;
            case "timeToLive": getOrCreateConfiguration((ActiveMQComponent) component).setTimeToLive((long) value); return true;
            case "allowAdditionalHeaders": getOrCreateConfiguration((ActiveMQComponent) component).setAllowAdditionalHeaders((java.lang.String) value); return true;
            case "allowNullBody": getOrCreateConfiguration((ActiveMQComponent) component).setAllowNullBody((boolean) value); return true;
            case "alwaysCopyMessage": getOrCreateConfiguration((ActiveMQComponent) component).setAlwaysCopyMessage((boolean) value); return true;
            case "correlationProperty": getOrCreateConfiguration((ActiveMQComponent) component).setCorrelationProperty((java.lang.String) value); return true;
            case "disableTimeToLive": getOrCreateConfiguration((ActiveMQComponent) component).setDisableTimeToLive((boolean) value); return true;
            case "forceSendOriginalMessage": getOrCreateConfiguration((ActiveMQComponent) component).setForceSendOriginalMessage((boolean) value); return true;
            case "includeSentJMSMessageID": getOrCreateConfiguration((ActiveMQComponent) component).setIncludeSentJMSMessageID((boolean) value); return true;
            case "replyCorrelationProperty": getOrCreateConfiguration((ActiveMQComponent) component).setReplyCorrelationProperty((java.lang.String) value); return true;
            case "replyToCacheLevelName": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToCacheLevelName((java.lang.String) value); return true;
            case "replyToDestinationSelectorName": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToDestinationSelectorName((java.lang.String) value); return true;
            case "streamMessageTypeEnabled": getOrCreateConfiguration((ActiveMQComponent) component).setStreamMessageTypeEnabled((boolean) value); return true;
            case "allowAutoWiredConnectionFactory": ((ActiveMQComponent) component).setAllowAutoWiredConnectionFactory((boolean) value); return true;
            case "allowAutoWiredDestinationResolver": ((ActiveMQComponent) component).setAllowAutoWiredDestinationResolver((boolean) value); return true;
            case "allowSerializedHeaders": getOrCreateConfiguration((ActiveMQComponent) component).setAllowSerializedHeaders((boolean) value); return true;
            case "artemisStreamingEnabled": getOrCreateConfiguration((ActiveMQComponent) component).setArtemisStreamingEnabled((boolean) value); return true;
            case "asyncStartListener": getOrCreateConfiguration((ActiveMQComponent) component).setAsyncStartListener((boolean) value); return true;
            case "asyncStopListener": getOrCreateConfiguration((ActiveMQComponent) component).setAsyncStopListener((boolean) value); return true;
            case "autowiredEnabled": ((ActiveMQComponent) component).setAutowiredEnabled((boolean) value); return true;
            case "browseLimit": getOrCreateConfiguration((ActiveMQComponent) component).setBrowseLimit((int) value); return true;
            case "configuration": ((ActiveMQComponent) component).setConfiguration((org.apache.camel.component.jms.JmsConfiguration) value); return true;
            case "destinationResolver": getOrCreateConfiguration((ActiveMQComponent) component).setDestinationResolver((org.springframework.jms.support.destination.DestinationResolver) value); return true;
            case "errorHandler": getOrCreateConfiguration((ActiveMQComponent) component).setErrorHandler((org.springframework.util.ErrorHandler) value); return true;
            case "exceptionListener": getOrCreateConfiguration((ActiveMQComponent) component).setExceptionListener((jakarta.jms.ExceptionListener) value); return true;
            case "idleConsumerLimit": getOrCreateConfiguration((ActiveMQComponent) component).setIdleConsumerLimit((int) value); return true;
            case "idleReceivesPerTaskLimit": getOrCreateConfiguration((ActiveMQComponent) component).setIdleReceivesPerTaskLimit((int) value); return true;
            case "idleTaskExecutionLimit": getOrCreateConfiguration((ActiveMQComponent) component).setIdleTaskExecutionLimit((int) value); return true;
            case "includeAllJMSXProperties": getOrCreateConfiguration((ActiveMQComponent) component).setIncludeAllJMSXProperties((boolean) value); return true;
            case "includeCorrelationIDAsBytes": ((ActiveMQComponent) component).setIncludeCorrelationIDAsBytes((boolean) value); return true;
            case "jmsKeyFormatStrategy": getOrCreateConfiguration((ActiveMQComponent) component).setJmsKeyFormatStrategy((org.apache.camel.component.jms.JmsKeyFormatStrategy) value); return true;
            case "mapJmsMessage": getOrCreateConfiguration((ActiveMQComponent) component).setMapJmsMessage((boolean) value); return true;
            case "maxMessagesPerTask": getOrCreateConfiguration((ActiveMQComponent) component).setMaxMessagesPerTask((int) value); return true;
            case "messageConverter": getOrCreateConfiguration((ActiveMQComponent) component).setMessageConverter((org.springframework.jms.support.converter.MessageConverter) value); return true;
            case "messageCreatedStrategy": getOrCreateConfiguration((ActiveMQComponent) component).setMessageCreatedStrategy((org.apache.camel.component.jms.MessageCreatedStrategy) value); return true;
            case "messageIdEnabled": getOrCreateConfiguration((ActiveMQComponent) component).setMessageIdEnabled((boolean) value); return true;
            case "messageListenerContainerFactory": getOrCreateConfiguration((ActiveMQComponent) component).setMessageListenerContainerFactory((org.apache.camel.component.jms.MessageListenerContainerFactory) value); return true;
            case "messageTimestampEnabled": getOrCreateConfiguration((ActiveMQComponent) component).setMessageTimestampEnabled((boolean) value); return true;
            case "pubSubNoLocal": getOrCreateConfiguration((ActiveMQComponent) component).setPubSubNoLocal((boolean) value); return true;
            case "queueBrowseStrategy": ((ActiveMQComponent) component).setQueueBrowseStrategy((org.apache.camel.component.jms.QueueBrowseStrategy) value); return true;
            case "receiveTimeout": getOrCreateConfiguration((ActiveMQComponent) component).setReceiveTimeout((long) value); return true;
            case "recoveryInterval": getOrCreateConfiguration((ActiveMQComponent) component).setRecoveryInterval((long) value); return true;
            case "requestTimeoutCheckerInterval": getOrCreateConfiguration((ActiveMQComponent) component).setRequestTimeoutCheckerInterval((long) value); return true;
            case "serviceLocationEnabled": ((ActiveMQComponent) component).setServiceLocationEnabled((boolean) value); return true;
            case "synchronous": getOrCreateConfiguration((ActiveMQComponent) component).setSynchronous((boolean) value); return true;
            case "temporaryQueueResolver": getOrCreateConfiguration((ActiveMQComponent) component).setTemporaryQueueResolver((org.apache.camel.component.jms.TemporaryQueueResolver) value); return true;
            case "transferException": getOrCreateConfiguration((ActiveMQComponent) component).setTransferException((boolean) value); return true;
            case "transferExchange": getOrCreateConfiguration((ActiveMQComponent) component).setTransferExchange((boolean) value); return true;
            case "trustAllPackages": ((ActiveMQComponent) component).setTrustAllPackages((boolean) value); return true;
            case "useMessageIDAsCorrelationID": getOrCreateConfiguration((ActiveMQComponent) component).setUseMessageIDAsCorrelationID((boolean) value); return true;
            case "waitForProvisionCorrelationToBeUpdatedCounter": getOrCreateConfiguration((ActiveMQComponent) component).setWaitForProvisionCorrelationToBeUpdatedCounter((int) value); return true;
            case "waitForProvisionCorrelationToBeUpdatedThreadSleepingTime": getOrCreateConfiguration((ActiveMQComponent) component).setWaitForProvisionCorrelationToBeUpdatedThreadSleepingTime((long) value); return true;
            case "waitForTemporaryReplyToToBeUpdatedCounter": getOrCreateConfiguration((ActiveMQComponent) component).setWaitForTemporaryReplyToToBeUpdatedCounter((int) value); return true;
            case "waitForTemporaryReplyToToBeUpdatedThreadSleepingTime": getOrCreateConfiguration((ActiveMQComponent) component).setWaitForTemporaryReplyToToBeUpdatedThreadSleepingTime((long) value); return true;
            case "headerFilterStrategy": ((ActiveMQComponent) component).setHeaderFilterStrategy((org.apache.camel.spi.HeaderFilterStrategy) value); return true;
            case "errorHandlerLoggingLevel": getOrCreateConfiguration((ActiveMQComponent) component).setErrorHandlerLoggingLevel((org.apache.camel.LoggingLevel) value); return true;
            case "errorHandlerLogStackTrace": getOrCreateConfiguration((ActiveMQComponent) component).setErrorHandlerLogStackTrace((boolean) value); return true;
            case "password": getOrCreateConfiguration((ActiveMQComponent) component).setPassword((java.lang.String) value); return true;
            case "username": getOrCreateConfiguration((ActiveMQComponent) component).setUsername((java.lang.String) value); return true;
            case "transacted": getOrCreateConfiguration((ActiveMQComponent) component).setTransacted((boolean) value); return true;
            case "transactedInOut": getOrCreateConfiguration((ActiveMQComponent) component).setTransactedInOut((boolean) value); return true;
            case "lazyCreateTransactionManager": getOrCreateConfiguration((ActiveMQComponent) component).setLazyCreateTransactionManager((boolean) value); return true;
            case "transactionManager": getOrCreateConfiguration((ActiveMQComponent) component).setTransactionManager((org.springframework.transaction.PlatformTransactionManager) value); return true;
            case "transactionName": getOrCreateConfiguration((ActiveMQComponent) component).setTransactionName((java.lang.String) value); return true;
            case "transactionTimeout": getOrCreateConfiguration((ActiveMQComponent) component).setTransactionTimeout((int) value); return true;
            default: return false;
            }
        }

    public GenericFileProcessStrategy<FTPFile> createGenericFileProcessStrategy(
            CamelContext context, Map<String, Object> params) {

         
         
        Expression moveExpression = (Expression) params.get("move");
        Expression moveFailedExpression = (Expression) params.get("moveFailed");
        Expression preMoveExpression = (Expression) params.get("preMove");
        boolean isNoop = params.get("noop") != null;
        boolean isDelete = params.get("delete") != null;
        boolean isMove = moveExpression != null || preMoveExpression != null || moveFailedExpression != null;

        if (isDelete) {
            GenericFileDeleteProcessStrategy<FTPFile> strategy = new GenericFileDeleteProcessStrategy<>();
            strategy.setExclusiveReadLockStrategy(getExclusiveReadLockStrategy(params));
            if (preMoveExpression != null) {
                GenericFileExpressionRenamer<FTPFile> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(preMoveExpression);
                strategy.setBeginRenamer(renamer);
            }
            if (moveFailedExpression != null) {
                GenericFileExpressionRenamer<FTPFile> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(moveFailedExpression);
                strategy.setFailureRenamer(renamer);
            }
            return strategy;
        } else if (isMove || isNoop) {
            GenericFileRenameProcessStrategy<FTPFile> strategy = new GenericFileRenameProcessStrategy<>();
            strategy.setExclusiveReadLockStrategy(getExclusiveReadLockStrategy(params));
            if (!isNoop && moveExpression != null) {
                 
                GenericFileExpressionRenamer<FTPFile> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(moveExpression);
                strategy.setCommitRenamer(renamer);
            }
             
            if (moveFailedExpression != null) {
                GenericFileExpressionRenamer<FTPFile> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(moveFailedExpression);
                strategy.setFailureRenamer(renamer);
            }
             
            if (preMoveExpression != null) {
                GenericFileExpressionRenamer<FTPFile> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(preMoveExpression);
                strategy.setBeginRenamer(renamer);
            }
            return strategy;
        } else {
             
            GenericFileNoOpProcessStrategy<FTPFile> strategy = new GenericFileNoOpProcessStrategy<>();
            strategy.setExclusiveReadLockStrategy(getExclusiveReadLockStrategy(params));
            return strategy;
        }
    }

    public GoogleCalendarConfiguration getEndpointConfiguration(GoogleCalendarApiName apiName) {
        GoogleCalendarConfiguration result = null;
        switch (apiName) {
            case ACL:
                result = new CalendarAclEndpointConfiguration();
                break;
            case LIST:
                result = new CalendarCalendarListEndpointConfiguration();
                break;
            case CALENDARS:
                result = new CalendarCalendarsEndpointConfiguration();
                break;
            case CHANNELS:
                result = new CalendarChannelsEndpointConfiguration();
                break;
            case COLORS:
                result = new CalendarColorsEndpointConfiguration();
                break;
            case FREEBUSY:
                result = new CalendarFreebusyEndpointConfiguration();
                break;
            case EVENTS:
                result = new CalendarEventsEndpointConfiguration();
                break;
            case SETTINGS:
                result = new CalendarSettingsEndpointConfiguration();
                break;
        }
        return result;
    }

    private void updateClientScope(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientScopeId = exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_ID, String.class);
        if (ObjectHelper.isEmpty(clientScopeId)) {
            throw new IllegalArgumentException("Client scope ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientScopeRepresentation) {
                keycloakClient.realm(realmName).clientScopes().get(clientScopeId).update((ClientScopeRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client scope updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client scope requires POJO request with ClientScopeRepresentation");
        }
    }

    protected void getValues(Message message) throws Exception {
        Object result;

        boolean asString = message.getHeader(ConsulConstants.CONSUL_VALUE_AS_STRING, getConfiguration().isValueAsString(),
                Boolean.class);
        if (asString) {
            result = getClient().getValuesAsString(
                    getMandatoryHeader(message, ConsulConstants.CONSUL_KEY, getConfiguration().getKey(), String.class));
        } else {
            result = getClient().getValues(
                    getMandatoryHeader(message, ConsulConstants.CONSUL_KEY, getConfiguration().getKey(), String.class),
                    message.getHeader(ConsulConstants.CONSUL_OPTIONS, QueryOptions.BLANK, QueryOptions.class));
        }

        setBodyAndResult(message, result);
    }

    public void setSigPolicyIdDocumentationReferences(List<String> sigPolicyIdDocumentationReferences) {
        if (sigPolicyIdDocumentationReferences == null) {
            throw new IllegalArgumentException("Parameter 'sigPolicyIdDocumentationReferences' is null");
        }
        for (String ref : sigPolicyIdDocumentationReferences) {
            if (ref == null || ref.isEmpty()) {
                throw new IllegalArgumentException(
                        "At least one documentation reference of the signature policy is null or empty");
            }
        }
        this.sigPolicyIdDocumentationReferences = sigPolicyIdDocumentationReferences;
    }

    protected void doCall(Map<String, Object> options, Function<ManagedRouteMBean, Object> task) {
        String path = (String) options.get(Exchange.HTTP_PATH);
        String subPath = path != null ? StringHelper.after(path, "/") : null;
        String filter = (String) options.get(FILTER);
        String limit = (String) options.get(LIMIT);
        final int max = limit == null ? Integer.MAX_VALUE : Integer.parseInt(limit);

        ManagedCamelContext mcc = getCamelContext().getCamelContextExtension().getContextPlugin(ManagedCamelContext.class);
        if (mcc != null) {
            List<Route> routes = getCamelContext().getRoutes();
            routes.sort((o1, o2) -> o1.getRouteId().compareToIgnoreCase(o2.getRouteId()));
            routes.stream()
                    .map(route -> mcc.getManagedRoute(route.getRouteId()))
                    .filter(Objects::nonNull)
                    .filter(r -> accept(r, filter))
                    .filter(r -> accept(r, subPath))
                    .sorted(RouteStructureDevConsole::sort)
                    .limit(max)
                    .forEach(task::apply);
        }
    }

    public void getJob(String jobId, Map<String, List<String>> headers, final JobInfoResponseCallback callback) {
        final Request get = getRequest(HttpMethod.GET, jobUrl(jobId), headers);

         
        doHttpRequest(get, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                JobInfo value = null;
                try {
                    value = unmarshalResponse(response, get, JobInfo.class);
                } catch (SalesforceException e) {
                    ex = e;
                }
                callback.onResponse(value, headers, ex);
            }
        });
    }

    protected AbstractMessageListenerContainer createListenerContainer() throws Exception {
        if (endpoint.getConfiguration().getReplyToConsumerType() == ConsumerType.Default) {
            return createDefaultListenerContainer();
        } else if (endpoint.getConfiguration().getReplyToConsumerType() == ConsumerType.Simple) {
            return createSimpleListenerContainer();
        } else {
            return getAbstractMessageListenerContainer(endpoint);
        }
    }

    private Expression createOrExpression(final Expression leftExp, final Expression rightExp) {
        return new Expression() {
            @Override
            public <T> T evaluate(Exchange exchange, Class<T> type) {
                Predicate predicate = ExpressionToPredicateAdapter.toPredicate(leftExp);
                predicate = PredicateBuilder.or(predicate, ExpressionToPredicateAdapter.toPredicate(rightExp));

                boolean answer = predicate.matches(exchange);
                return exchange.getContext().getTypeConverter().convertTo(type, answer);
            }

            @Override
            public String toString() {
                return left + " " + token.getText() + " " + right;
            }
        };
    }

    public static Expression uppercaseExpression(final String expression) {
        return new ExpressionAdapter() {
            private Expression exp;

            @Override
            public void init(CamelContext context) {
                if (expression != null) {
                    exp = context.resolveLanguage("simple").createExpression(expression);
                    exp.init(context);
                }
            }

            @Override
            public Object evaluate(Exchange exchange) {
                String value;
                if (exp != null) {
                    value = exp.evaluate(exchange, String.class);
                } else {
                    value = exchange.getMessage().getBody(String.class);
                }
                if (value != null) {
                    value = value.toUpperCase(Locale.ENGLISH);
                }
                return value;
            }

            @Override
            public String toString() {
                if (expression != null) {
                    return "uppercase(" + expression + ")";
                } else {
                    return "uppercase()";
                }
            }
        };
    }

    protected void doRemove(Exchange exchange, String operation) throws GitAPIException {
        String fileName = null;
        if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(GitConstants.GIT_FILE_NAME))) {
            fileName = exchange.getIn().getHeader(GitConstants.GIT_FILE_NAME, String.class);
        } else {
            throw new IllegalArgumentException("File name must be specified to execute " + operation);
        }
        try {
            if (ObjectHelper.isNotEmpty(endpoint.getBranchName())) {
                git.checkout().setCreateBranch(false).setName(endpoint.getBranchName()).call();
            }
            git.rm().addFilepattern(fileName).call();
        } catch (GitAPIException e) {
            LOG.error("There was an error in Git {} operation", operation);
            throw e;
        }
    }

    private static String evaluateTemplate(final String templateName, final JBangModel model) throws MojoExecutionException {
        StringBuilder sb = new StringBuilder(256);

        try (InputStream templateStream = UpdateReadmeMojo.class.getClassLoader().getResourceAsStream(templateName)) {
            String template = PackageHelper.loadText(templateStream);
             
            for (JBangModel.JBangGroupModel group : model.getGroups()) {
                Map<String, Object> root = new HashMap<>();
                root.put("group", group);
                root.put("options", model.getOptions().stream()
                        .filter(o -> o.getName().startsWith(group.getName()))
                        .toList());
                String eval
                        = (String) TemplateRuntime.eval(template, root, Collections.singletonMap("util", MvelHelper.INSTANCE));
                sb.append(eval);
                sb.append("\n");
            }
        } catch (IOException e) {
            throw new MojoExecutionException("Error processing mvel template `" + templateName + "`", e);
        }

        return sb.toString();
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        final EventHubsConfiguration configuration = this.configuration.copy();

        final EventHubsEndpoint endpoint = new EventHubsEndpoint(uri, this, configuration);
        setProperties(endpoint, parameters);

         
        if (isTokenCredentialSet(configuration)
                || !isProducerAsyncClientSet(configuration) && !isConnectionStringSet(configuration)) {
            checkAndSetNamespaceAndHubName(configuration, remaining);
        }

         
        if (endpoint.getConfiguration().getTokenCredential() == null) {
            if (endpoint.getConfiguration().getCredentialType() == null) {
                endpoint.getConfiguration().setCredentialType(CredentialType.CONNECTION_STRING);
            }
        } else {
            boolean azure = endpoint.getConfiguration().getTokenCredential() instanceof DefaultAzureCredential;
            endpoint.getConfiguration()
                    .setCredentialType(azure ? CredentialType.AZURE_IDENTITY : CredentialType.TOKEN_CREDENTIAL);
        }

        validateConfigurations(configuration);

        return endpoint;
    }

    void addReference(SedaEndpoint endpoint) {
        lock.lock();
        try {
            if (!endpoints.contains(endpoint)) {
                endpoints.add(endpoint);
                 
                if (endpoint.isMultipleConsumers()) {
                    multipleConsumers = true;
                }
            }
        } finally {
            lock.unlock();
        }
    }

    public static EipModel generateEipModel(JsonObject obj) {
        JsonObject mobj = (JsonObject) obj.get("model");
        EipModel model = new EipModel();
        parseModel(mobj, model);
        model.setAbstractModel(mobj.getBooleanOrDefault("abstract", false));
        model.setInput(mobj.getBooleanOrDefault("input", false));
        model.setOutput(mobj.getBooleanOrDefault("output", false));
        JsonObject mprp = (JsonObject) obj.get("properties");
        if (mprp != null) {
            for (Map.Entry<String, Object> entry : mprp.entrySet()) {
                JsonObject mp = (JsonObject) entry.getValue();
                EipOptionModel option = new EipOptionModel();
                parseOption(mp, option, entry.getKey());
                model.addOption(option);
            }
        }
        mprp = (JsonObject) obj.get("exchangeProperties");
        if (mprp != null) {
            for (Map.Entry<String, Object> entry : mprp.entrySet()) {
                JsonObject mp = (JsonObject) entry.getValue();
                EipOptionModel option = new EipOptionModel();
                parseOption(mp, option, entry.getKey());
                model.addExchangeProperty(option);
            }
        }
        return model;
    }

    public boolean release(PooledExchangeTask task) {
        try {
            task.reset();
            boolean inserted = pool.offer(task);
            if (statisticsEnabled) {
                if (inserted) {
                    statistics.released.increment();
                } else {
                    statistics.discarded.increment();
                }
            }
            return inserted;
        } catch (Exception e) {
            if (statisticsEnabled) {
                statistics.discarded.increment();
            }
            return false;
        }
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        try {
            OpenTelemetrySpanAdapter camelSpan = (OpenTelemetrySpanAdapter) ActiveSpanManager.getSpan(exchange);
            Span span = camelSpan.getOpenTelemetrySpan();
            if (span != null) {
                String tag = expression.evaluate(exchange, String.class);
                span.setAttribute(attributeName, tag);
            } else {
                LOG.warn("OpenTelemetry: Cannot find managed span for exchange: {}", exchange);
            }
        } catch (Exception e) {
            exchange.setException(e);
        } finally {
             
            callback.done(true);
        }

        return true;
    }

    public static String getPrimitiveType(String name) {
         
        if ("java.lang.byte[]".equals(name) || "byte[]".equals(name)) {
            return "string";
        } else if ("java.lang.Byte[]".equals(name) || "Byte[]".equals(name)) {
            return "array";
        } else if ("java.lang.Object[]".equals(name) || "Object[]".equals(name)) {
            return "array";
        } else if ("java.lang.String[]".equals(name) || "String[]".equals(name)) {
            return "array";
        } else if ("java.lang.Character".equals(name) || "Character".equals(name) || "char".equals(name)) {
            return "string";
        } else if ("java.lang.String".equals(name) || "String".equals(name)) {
            return "string";
        } else if ("java.lang.Boolean".equals(name) || "Boolean".equals(name) || "boolean".equals(name)) {
            return "boolean";
        } else if ("java.lang.Integer".equals(name) || "Integer".equals(name) || "int".equals(name)) {
            return "integer";
        } else if ("java.lang.Long".equals(name) || "Long".equals(name) || "long".equals(name)) {
            return "integer";
        } else if ("java.lang.Short".equals(name) || "Short".equals(name) || "short".equals(name)) {
            return "integer";
        } else if ("java.lang.Byte".equals(name) || "Byte".equals(name) || "byte".equals(name)) {
            return "integer";
        } else if ("java.lang.Float".equals(name) || "Float".equals(name) || "float".equals(name)) {
            return "number";
        } else if ("java.lang.Double".equals(name) || "Double".equals(name) || "double".equals(name)) {
            return "number";
        }

        return null;
    }

    static long write(FileChannel fileChannel, ByteBuffer byteBuffer) throws IOException {
        long bytesWritten = 0;
        byteBuffer.flip();

        while (byteBuffer.hasRemaining()) {
            bytesWritten += fileChannel.write(byteBuffer);
        }

        byteBuffer.flip();
        byteBuffer.clear();

        return bytesWritten;
    }

    protected void doStart() throws Exception {
        super.doStart();

        connectOptions = PahoEndpoint.createMqttConnectOptions(getEndpoint().getConfiguration());

        if (client == null) {
            clientId = getEndpoint().getConfiguration().getClientId();
            if (clientId == null) {
                clientId = "camel-" + MqttClient.generateClientId();
            }
            stopClient = true;
            client = new MqttClient(
                    getEndpoint().getConfiguration().getBrokerUrl(),
                    clientId,
                    PahoEndpoint.createMqttClientPersistence(getEndpoint().getConfiguration()));
            LOG.debug("Connecting client: {} to broker: {}", clientId, getEndpoint().getConfiguration().getBrokerUrl());
            client.connect(connectOptions);
        }
    }

    public static <I, T extends Throwable> Consumer<I> wrapAsConsumer(ThrowingConsumer<I, T> consumer) {
        return new Consumer<>() {
            @Override
            public void accept(I in) {
                try {
                    consumer.accept(in);
                } catch (Throwable t) {
                    throw new RuntimeException(t);
                }
            }
        };
    }

    protected String asTypeName(Class<?> classType) {
         
         
         
         
         
         
         
         

        String type;

        if (classType.isArray()) {
            type = classType.getComponentType().getName() + "[]";
        } else {
            type = classType.getName();
        }

        return type;
    }

    protected boolean isInputStreamNeeded(Object payload) {
        if (payload == null) {
            return false;
        }

        if (payload instanceof Source) {
            return false;
        } else if (payload instanceof String) {
            return false;
        } else if (payload instanceof byte[]) {
            return false;
        } else if (payload instanceof Node) {
            return false;
        }

         
        return true;
    }

    private void doAttach(Exchange exchange) {
        final Message msg = exchange.getIn();
        final String routerId = msg.getHeader(NeutronConstants.ROUTER_ID, String.class);
        final String subnetPortId
                = msg.getHeader(NeutronConstants.SUBNET_ID, msg.getHeader(NeutronConstants.PORT_ID), String.class);
        final AttachInterfaceType type = msg.getHeader(NeutronConstants.ITERFACE_TYPE, AttachInterfaceType.class);
        StringHelper.notEmpty(routerId, "Router ID");
        StringHelper.notEmpty(subnetPortId, "Subnet/Port ID");
        ObjectHelper.notNull(type, "AttachInterfaceType ");
        RouterInterface routerInterface = os.networking().router().attachInterface(routerId, type, subnetPortId);
        msg.setBody(routerInterface);
    }

    private Message getNextElement() {
        if (asn1InputStream == null) {
            return null;
        }

        try {
            ASN1Primitive current = getNextEntry();

            if (current != null) {
                Message answer = new DefaultMessage(exchange.getContext());
                answer.getHeaders().putAll(exchange.getIn().getHeaders());
                answer.setBody(current.getEncoded());
                return answer;
            } else {
                LOGGER.trace("close asn1InputStream");
                return null;
            }
        } catch (IOException exception) {
            throw new RuntimeCamelException(exception);
        }
    }

    private void createGroup(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof GroupRepresentation) {
                Response response = keycloakClient.realm(realmName).groups().add((GroupRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            GroupRepresentation group = new GroupRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.GROUP_NAME))) {
                String groupName = exchange.getIn().getHeader(KeycloakConstants.GROUP_NAME, String.class);
                group.setName(groupName);
            } else {
                throw new IllegalArgumentException(MISSING_GROUP_NAME);
            }
            Response response = keycloakClient.realm(realmName).groups().add(group);
            Message message = getMessageForResponse(exchange);
            message.setBody(response);
        }
    }

    public static Predicate isEqualTo(final Expression left, final Expression right) {
        return new BinaryPredicateSupport(left, right) {

            protected boolean matches(Exchange exchange, Object leftValue, Object rightValue) {
                if (leftValue == null && rightValue == null) {
                     
                    return true;
                } else if (leftValue == null || rightValue == null) {
                     
                    return false;
                }

                return ObjectHelper.typeCoerceEquals(exchange.getContext().getTypeConverter(), leftValue, rightValue);
            }

            protected String getOperationText() {
                return "==";
            }
        };
    }

    private FTPFile[] getFtpFilesByFilter(GenericFileOperations<FTPFile> operations, GenericFile<FTPFile> file) {
         
         
        String path = file.getParent();
        if (path.equals("/") || path.equals("\\")) {
             
            LOG.trace(
                    "Using full directory listing in home directory to update file information. Consider enabling fastExistsCheck option.");
            return operations.listFiles();
        } else {
            LOG.trace(
                    "Using full directory listing to update file information for {}. Consider enabling fastExistsCheck option.",
                    path);
            return operations.listFiles(path);
        }
    }

    public void receive(String requestUriPattern, HttpRequestHandler handler) {
        if (listenerThread != null) {
            lock.lock();
            try {
                listenerThread.registerHandler(requestUriPattern, handler);
            } finally {
                lock.unlock();
            }
        }
    }

        protected void onExceptionOccurred() {
            if (onExceptionProcessor == null) {
                return;
            }

             
            try {
                if (LOG.isTraceEnabled()) {
                    LOG.trace("OnExceptionOccurred processor {} is processing Exchange: {} due exception occurred",
                            onExceptionProcessor, exchange);
                }
                onExceptionProcessor.process(exchange);
            } catch (Exception e) {
                 
                LOG.warn("Error during processing OnExceptionOccurred. This exception is ignored.", e);
            }
            LOG.trace("OnExceptionOccurred processor done");
        }

    protected void afterConfiguration(String uri, String remaining, Endpoint endpoint, Map<String, Object> parameters)
            throws Exception {
        AtomEndpoint atom = (AtomEndpoint) endpoint;
        if (atom.getFeedUri() != null) {
             
            return;
        }

         
         
        String feedUri;
        if (!parameters.isEmpty()) {
            URI remainingUri = URISupport.createRemainingURI(new URI(remaining), parameters);
            feedUri = remainingUri.toString();
        } else {
            feedUri = remaining;
        }

        atom.setFeedUri(feedUri);
    }

    protected String doCallText(Map<String, Object> options) {
        StringBuilder sb = new StringBuilder();

        if (rr != null) {
            for (RestRegistry.RestService rs : rr.listAllRestServices()) {
                if (!sb.isEmpty()) {
                    sb.append("\n");
                }
                sb.append(String.format("\n    Url: %s", rs.getUrl()));
                sb.append(String.format("\n    Method: %s", rs.getMethod()));
                sb.append(String.format("\n    State: %s", rs.getState()));
                if (rs.getConsumes() != null) {
                    sb.append(String.format("\n    Consumes: %s", rs.getConsumes()));
                }
                if (rs.getProduces() != null) {
                    sb.append(String.format("\n    Produces: %s", rs.getProduces()));
                }
                if (rs.getInType() != null) {
                    sb.append(String.format("\n    In Type: %s", rs.getInType()));
                }
                if (rs.getOutType() != null) {
                    sb.append(String.format("\n    Out Type: %s", rs.getOutType()));
                }
                if (rs.getDescription() != null) {
                    sb.append(String.format("\n    Description: %s", rs.getDescription()));
                }
            }
            sb.append("\n");
        }

        return sb.toString();
    }

    protected void basePackageScanQuarkus(String... basePackage) throws Exception {
         
        PackageScanClassResolver pscr = PluginHelper.getPackageScanClassResolver(camelContext);
        Set<Class<?>> found
                = pscr.findByFilter(c -> AnnotationHelper.hasAnnotation(c, "jakarta.enterprise.context.ApplicationScoped")
                        || AnnotationHelper.hasAnnotation(c, "jakarta.inject.Singleton"), basePackage);
        for (Class<?> clazz : found) {
             
            String fqn = clazz.getName();
            if (scanned.contains(fqn)) {
                continue;
            } else {
                scanned.add(fqn);
            }

            LOG.debug("Discovered Quarkus @ApplicationScoped/@Singleton class: {}", clazz);

             
            String name = null;
            var ann = AnnotationHelper.getAnnotationValue(clazz, "javax.inject.Named");
            if (ann != null) {
                name = ann;
            }
            if (name == null || name.isBlank()) {
                name = clazz.getSimpleName();
                 
                name = StringHelper.decapitalize(name);
            }
             
            Supplier<Object> supplier = () -> camelContext.getInjector().newInstance(clazz, true);
            bindBean(camelContext, clazz, name, supplier, "Quarkus @ApplicationScoped/@Singleton");
        }
    }

    private String getId(SuspendedRow r) {
        if (r.first) {
            return "*-->";
        } else if (r.last) {
            return "*<--";
        } else {
            return r.nodeId;
        }
    }

    public void execute() throws MojoExecutionException {
        File camelDir = findCamelDirectory(baseDir, "core/camel-util");
        if (camelDir == null) {
            getLog().debug("No core/camel-util folder found, skipping execution");
            return;
        }
        List<Path> jsonFiles;
        try (Stream<Path> stream = PackageHelper.findJsonFiles(jsonDir.toPath())) {
            jsonFiles = stream.toList();
        }
        Set<String> importants = new TreeSet<>();

        for (Path file : jsonFiles) {
            final String name = PackageHelper.asName(file);

            try {
                String json = PackageHelper.loadText(file.toFile());
                Object jo = Jsoner.deserialize(json);
                JsonObject obj;
                if (jo instanceof JsonObject) {
                    obj = (JsonObject) jo;
                } else {
                    continue;
                }

                boolean isComponent = obj.getMap("component") != null;
                boolean isEip = !isComponent && obj.getMap("model") != null;

                 
                if (!isComponent && !isEip) {
                    continue;
                }

                if (isComponent) {
                    ComponentModel cm = JsonMapper.generateComponentModel(json);
                    cm.getEndpointHeaders().forEach(o -> {
                        if (o.isImportant()) {
                            importants.add(o.getName());
                        }
                    });
                } else if (isEip) {
                    EipModel em = JsonMapper.generateEipModel(json);
                    em.getExchangeProperties().forEach(o -> {
                        if (o.isImportant()) {
                            importants.add(o.getName());
                        }
                    });
                }
            } catch (Exception e) {
                throw new MojoExecutionException("Error loading json: " + name, e);
            }
        }

        getLog().info("There are " + importants.size()
                      + " distinct important options across all the Camel components/eips");

        try {
            boolean updated = updateImportantHeaderKeys(camelDir, importants);
            if (updated) {
                getLog().info("Updated camel-util/src/main/java/org/apache/camel/util/ImportantHeaderUtils.java file");
            } else {
                getLog().debug("No changes to camel-util/src/main/java/org/apache/camel/util/ImportantHeaderUtils.java file");
            }
        } catch (Exception e) {
            throw new MojoExecutionException("Error updating ImportantHeaderUtils.java", e);
        }

        try {
            updateImportantHeaderJsonSchema(baseDir, importants);
        } catch (Exception e) {
            throw new MojoExecutionException("Error updating important-headers.json", e);
        }
    }

    public String apply(String remainder) {
        String key = remainder;
        String defaultValue = null;

        if (remainder.contains(":")) {
            key = StringHelper.before(remainder, ":");
            defaultValue = StringHelper.after(remainder, ":");
        }

        String value = System.getProperty(key);
        return value != null ? value : defaultValue;
    }

    public Integer doCall() throws Exception {
        List<Long> pids = findPids(name);
        for (long pid : pids) {
            JsonObject root = new JsonObject();
            root.put("action", "gc");
            Path f = getActionFile(Long.toString(pid));
            PathUtils.writeTextSafely(root.toJson(), f);
        }

        return 0;
    }

    protected Class<?> loadClass(String name, ClassLoader loader) {
        Class<?> answer = null;
        try {
            answer = ObjectHelper.loadClass(name, loader);
        } catch (Exception e) {
             
        }

        if (answer == null) {
             
            MavenGav gav = knownDependenciesResolver.mavenGavForClass(name);
            if (gav == null) {
                 
                 
                String last = StringHelper.afterLast(name, ".", name);
                PojoBeanModel model = catalog.pojoBeanModel(last);
                if (model != null && name.equals(model.getJavaType())) {
                    gav = MavenGav.fromCoordinates(model.getGroupId(), model.getArtifactId(), model.getVersion(), null, null);
                }
            }
            if (gav != null) {
                if (!downloader.alreadyOnClasspath(gav.getGroupId(), gav.getArtifactId(),
                        gav.getVersion())) {
                    downloader.downloadDependency(gav.getGroupId(), gav.getArtifactId(),
                            gav.getVersion());
                }
                try {
                    answer = ObjectHelper.loadClass(name, loader);
                } catch (Exception e) {
                     
                }
            }
        }

        return answer;
    }

    public List<CamelClusterMember> getMembers() {
        if (leaderSelector == null) {
            return Collections.emptyList();
        }

        try {
            return leaderSelector.getParticipants()
                    .stream()
                    .map(CuratorClusterMember::new)
                    .collect(Collectors.toList());
        } catch (KeeperException.NoNodeException e) {
            LOGGER.debug("Failed to get members because node '{}' does not yet exist (error: '{}')",
                    getFullPath(),
                    e.getMessage());
            return Collections.emptyList();
        } catch (Exception e) {
            throw new RuntimeCamelException(e);
        }
    }

    public Exchange aggregate(Exchange oldExchange, Exchange newExchange) {
         
        Object objBody = newExchange.getIn().getBody();
        if (!(objBody instanceof BulkOperation[])) {
            throw new InvalidPayloadRuntimeException(newExchange, BulkOperation[].class);
        }

        BulkOperation[] newBody = (BulkOperation[]) objBody;
        BulkRequest.Builder builder = new BulkRequest.Builder();
        builder.operations(List.of(newBody));
        if (oldExchange != null) {
            BulkRequest request = oldExchange.getIn().getBody(BulkRequest.class);
            builder.operations(request.operations());
        }
        newExchange.getIn().setBody(builder.build());
        return oldExchange;
    }

    public void process(Exchange exchange) throws Exception {

        ClientConfigurations clientConfigurations = new ClientConfigurations();

        if (obsClient == null) {
            this.obsClient = endpoint.initClient();
        }

        updateClientConfigs(exchange, clientConfigurations);

        switch (clientConfigurations.getOperation()) {
            case OBSOperations.LIST_BUCKETS:
                listBuckets(exchange);
                break;
            case OBSOperations.CREATE_BUCKET:
                createBucket(exchange, clientConfigurations);
                break;
            case OBSOperations.DELETE_BUCKET:
                deleteBucket(exchange, clientConfigurations);
                break;
            case OBSOperations.CHECK_BUCKET_EXISTS:
                checkBucketExists(exchange, clientConfigurations);
                break;
            case OBSOperations.GET_BUCKET_METADATA:
                getBucketMetadata(exchange, clientConfigurations);
                break;
            case OBSOperations.LIST_OBJECTS:
                listObjects(exchange, clientConfigurations);
                break;
            case OBSOperations.GET_OBJECT:
                getObject(exchange, clientConfigurations);
                break;
            case OBSOperations.PUT_OBJECT:
                putObject(exchange, clientConfigurations);
                break;
            default:
                throw new UnsupportedOperationException(
                        String.format("%s is not a supported operation", clientConfigurations.getOperation()));
        }
    }

    public DocFlavor forMimeTypeUTF8(String flavor, String mimeType) {
        if (mimeType.equalsIgnoreCase("TEXT_HTML_UTF_16BE")) {
            if (flavor.equalsIgnoreCase("DocFlavor.BYTE_ARRAY")) {
                d = DocFlavor.BYTE_ARRAY.TEXT_HTML_UTF_8;
            } else if (flavor.equalsIgnoreCase("DocFlavor.INPUT_STREAM")) {
                d = DocFlavor.INPUT_STREAM.TEXT_HTML_UTF_8;
            } else if (flavor.equalsIgnoreCase("DocFlavor.URL")) {
                d = DocFlavor.URL.TEXT_HTML_UTF_8;
            }
        } else {
            if (flavor.equalsIgnoreCase("DocFlavor.BYTE_ARRAY")) {
                d = DocFlavor.BYTE_ARRAY.TEXT_PLAIN_UTF_8;
            } else if (flavor.equalsIgnoreCase("DocFlavor.INPUT_STREAM")) {
                d = DocFlavor.INPUT_STREAM.TEXT_PLAIN_UTF_8;
            } else if (flavor.equalsIgnoreCase("DocFlavor.URL")) {
                d = DocFlavor.URL.TEXT_PLAIN_UTF_8;
            }
        }

        return d;
    }

    protected void doListHPAByLabel(Exchange exchange) {
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        Map<String, String> labels = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_HPA_LABELS, Map.class);
        HorizontalPodAutoscalerList hpaList;

        if (ObjectHelper.isEmpty(labels)) {
            LOG.error("Get HPA by labels require specify a labels set");
            throw new IllegalArgumentException("Get HPA by labels require specify a labels set");
        }

        if (ObjectHelper.isEmpty(namespace)) {
            hpaList = getEndpoint().getKubernetesClient().autoscaling().v1().horizontalPodAutoscalers().inAnyNamespace()
                    .withLabels(labels).list();
        } else {
            hpaList = getEndpoint().getKubernetesClient().autoscaling().v1().horizontalPodAutoscalers().inNamespace(namespace)
                    .withLabels(labels).list();
        }

        prepareOutboundMessage(exchange, hpaList.getItems());
    }

    public void enableById(String id) {
        Optional<HealthCheck> hc = healthCheckRegistry.getCheck(id);
        if (hc.isPresent()) {
            hc.get().setEnabled(true);
        } else {
            Optional<HealthCheckRepository> hcr = healthCheckRegistry.getRepository(id);
            hcr.ifPresent(repository -> repository.setEnabled(true));
        }
    }

            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                if (ex != null) {
                    callback.onResponse(null, headers, ex);
                }
                QueryJob responseJob = null;
                try {
                    responseJob = unmarshalResponse(response, request, QueryJob.class);
                } catch (SalesforceException e) {
                    ex = e;
                }
                callback.onResponse(responseJob, headers, ex);
            }

    public static AS2MessageDispositionNotificationEntity parseMessageDispositionNotificationEntityBody(
            AS2SessionInputBuffer inbuffer,
            InputStream is,
            String boundary,
            String charsetName)
            throws ParseException {
        CharsetDecoder previousDecoder = inbuffer.getCharsetDecoder();

        try {

            if (charsetName == null) {
                charsetName = StandardCharsets.US_ASCII.name();
            }
            Charset charset = Charset.forName(charsetName);
            CharsetDecoder charsetDecoder = charset.newDecoder();

            inbuffer.setCharsetDecoder(charsetDecoder);

            List<CharArrayBuffer> dispositionNotificationFields = parseBodyPartFields(inbuffer, is, boundary,
                    BasicLineParser.INSTANCE, new ArrayList<>());

            AS2MessageDispositionNotificationEntity as2MessageDispositionNotificationEntity
                    = DispositionNotificationContentUtils.parseDispositionNotification(dispositionNotificationFields);
            return as2MessageDispositionNotificationEntity;
        } catch (Exception e) {
            ParseException parseException = new ParseException("failed to parse MDN entity");
            parseException.initCause(e);
            throw parseException;
        } finally {
            inbuffer.setCharsetDecoder(previousDecoder);
        }
    }

    private void doUpdate(Exchange exchange, SqlSession session) {
        Object result;
        Object in = getInput(exchange);
        if (in != null) {
            Iterator<?> iter;
            if (in instanceof Map) {
                 
                iter = Collections.singletonList(in).iterator();
            } else {
                iter = ObjectHelper.createIterator(in);
            }
            while (iter.hasNext()) {
                Object value = iter.next();
                LOG.trace("Updating: {} using statement: {}", value, statement);
                result = session.update(statement, value);
                doProcessResult(exchange, result, session);
            }
        } else {
            LOG.trace("Updating using statement: {}", statement);
            result = session.update(statement);
            doProcessResult(exchange, result, session);
        }
    }

    protected void doInit() throws Exception {
        super.doInit();

        Registry registry = getEndpoint().getCamelContext().getRegistry();
        Object service = registry.lookupByName(GitHubConstants.GITHUB_COMMIT_SERVICE);
        if (service != null) {
            LOG.debug("Using CommitService found in registry {}", service.getClass().getCanonicalName());
            commitService = (CommitService) service;
        } else {
            commitService = new CommitService();
        }

        initService(commitService);
    }

    public static byte[] exportPublicKey(PublicKey publicKey, KeyLifecycleManager.KeyFormat format) throws Exception {
        switch (format) {
            case PEM:
                return exportPublicKeyToPEM(publicKey);
            case DER:
            case X509:
                return publicKey.getEncoded();  
            default:
                throw new IllegalArgumentException("Unsupported format for public key: " + format);
        }
    }

    private Stream<? extends Member> findMethodsForClass(Class<?> c) {
        XmlAccessType accessType;
        if (c.getAnnotation(XmlAccessorType.class) != null && c != outputDefinitionClass) {
            accessType = c.getAnnotation(XmlAccessorType.class).value();
        } else {
            accessType = XmlAccessType.PUBLIC_MEMBER;
        }
        if (accessType == XmlAccessType.FIELD || accessType == XmlAccessType.NONE) {
            return Stream.of(c.getDeclaredMethods()).filter(m -> m.getName().startsWith("set") && m.getParameterCount() == 1)
                    .filter(m -> m.getAnnotation(XmlAttribute.class) != null || m.getAnnotation(XmlElement.class) != null
                            || m.getAnnotation(XmlElementRef.class) != null
                            || m.getAnnotation(XmlValue.class) != null)
                    .sorted(Comparator.comparing(Method::getName));
        } else {
            return Stream.of(c.getDeclaredMethods())
                    .filter(m -> Modifier.isPublic(m.getModifiers()) || accessType == XmlAccessType.PROPERTY)
                    .filter(m -> m.getName().startsWith("set") && m.getParameterCount() == 1)
                    .filter(m -> m.getAnnotation(XmlTransient.class) == null)
                    .sorted(Comparator.comparing(Method::getName));
        }
    }

    public MainConfigurationProperties withMainListeners(String listeners) {
        if (this.mainListenerClasses == null) {
            this.mainListenerClasses = "";
        }
        if (this.mainListenerClasses.isEmpty()) {
            this.mainListenerClasses = listeners;
        } else {
            this.mainListenerClasses = "," + listeners;
        }
        return this;
    }

    protected int sortRow(Row o1, Row o2) {
         
        int answer = super.sortRow(o1, o2);
        if (answer == 0) {
            int negate = 1;
            if (sort.startsWith("-")) {
                negate = -1;
            }
             
            long m1 = o1.mean != null ? Long.parseLong(o1.mean) : 0;
            long m2 = o2.mean != null ? Long.parseLong(o2.mean) : 0;
            if (m1 < m2) {
                answer = negate;
            } else if (m1 > m2) {
                answer = -1 * negate;
            }
        }
        return answer;
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer target = (org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public RestDefinition consumes(String mediaType) {
        if (getVerbs().isEmpty()) {
            this.consumes = mediaType;
        } else {
             
            VerbDefinition verb = getVerbs().get(getVerbs().size() - 1);
            verb.setConsumes(mediaType);
        }

        return this;
    }

    public static void configureConnects(Traits traitsSpec, String[] connects) {
        if (connects == null || connects.length == 0) {
            return;
        }
        ServiceBinding serviceBindingTrait = Optional.ofNullable(traitsSpec.getServiceBinding()).orElseGet(ServiceBinding::new);
        if (serviceBindingTrait.getServices() == null) {
            serviceBindingTrait.setServices(new ArrayList<>());
        }
        serviceBindingTrait.getServices().addAll(List.of(connects));
        traitsSpec.setServiceBinding(serviceBindingTrait);
    }

    private WatsonSpeechToTextOperations determineOperation(Exchange exchange) {
        WatsonSpeechToTextOperations operation
                = exchange.getIn().getHeader(WatsonSpeechToTextConstants.OPERATION, WatsonSpeechToTextOperations.class);

        if (operation == null) {
            operation = getEndpoint().getConfiguration().getOperation();
        }

        if (operation == null) {
            throw new IllegalArgumentException("Operation must be specified");
        }

        return operation;
    }

    public void getAllBatches(String jobId, Map<String, List<String>> headers, final BatchInfoListResponseCallback callback) {
        final Request get = getRequest(HttpMethod.GET, batchUrl(jobId, null), headers);

         
        doHttpRequest(get, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                BatchInfoList value = null;
                try {
                    value = unmarshalResponse(response, get, BatchInfoList.class);
                } catch (SalesforceException e) {
                    ex = e;
                }
                callback.onResponse(value != null ? value.getBatchInfo() : null, headers, ex);
            }
        });
    }

    public Set<Class<?>> findImplementations(Class<?> parent, String... packageNames) {
        if (packageNames == null) {
            return Collections.emptySet();
        }

        if (LOG.isDebugEnabled()) {
            LOG.debug("Searching for implementations of {} in packages: {}", parent.getName(), Arrays.asList(packageNames));
        }

        PackageScanFilter test = getCompositeFilter(new AssignableToPackageScanFilter(parent));
        Set<Class<?>> classes = new LinkedHashSet<>();
        for (String pkg : packageNames) {
            find(test, pkg, classes);
        }

        LOG.debug("Found: {}", classes);

        return classes;
    }

    public static URI createURI(Exchange exchange, String url, HttpCommonEndpoint endpoint) throws URISyntaxException {
        URI uri = new URI(url);
         
        String queryString = (String) exchange.getIn().removeHeader(Exchange.REST_HTTP_QUERY);
         
         
        if (queryString == null) {
            queryString = exchange.getIn().getHeader(Exchange.HTTP_RAW_QUERY, String.class);
        }
        if (queryString == null) {
            queryString = exchange.getIn().getHeader(Exchange.HTTP_QUERY, String.class);
        }
        if (queryString == null) {
            queryString = endpoint.getHttpUri().getRawQuery();
        }
         
        if (queryString == null) {
            queryString = uri.getRawQuery();
        }
        if (queryString != null) {
             
            queryString = UnsafeUriCharactersEncoder.encodeHttpURI(queryString);
            uri = URISupport.createURIWithQuery(uri, queryString);
        }
        return uri;
    }

    private void processGetBlobField(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {
        String sObjectName = determineSObjectName(exchange);
         
        final String sObjectBlobFieldName = getParameter(SOBJECT_BLOB_FIELD_NAME, exchange, IGNORE_BODY, NOT_OPTIONAL);

         
        final AbstractSObjectBase sObjectBase = exchange.getIn().getBody(AbstractSObjectBase.class);
        String sObjectId = determineSObjectId(exchange);

        restClient.getBlobField(sObjectName, sObjectId, sObjectBlobFieldName, determineHeaders(exchange),
                new RestClient.ResponseCallback() {
                    @Override
                    public void onResponse(InputStream response, Map<String, String> headers, SalesforceException exception) {
                        restoreFields(exchange, sObjectBase, sObjectId, null, null);
                        processResponse(exchange, response, headers, exception, callback);
                    }
                });
    }

    private String determineBucketName(Exchange exchange) {
        String bucketName = exchange.getMessage().getHeader(GoogleCloudStorageConstants.OVERRIDE_BUCKET_NAME, String.class);
        if (ObjectHelper.isEmpty(bucketName)) {
            bucketName = getConfiguration().getBucketName();
        }
        if (bucketName == null) {
            throw new IllegalArgumentException("Bucket name is missing or not configured.");
        }
        return bucketName;
    }

    protected void execute(boolean dto) throws MojoExecutionException {
        if (skip) {
            return;
        }

        OpenAPI openapi = new OpenAPIV3Parser().read(specificationUri);

        if (openapi == null) {
            throw new MojoExecutionException(
                    "Unable to generate REST DSL OpenApi sources from specification: "
                                             + specificationUri
                                             + ", make sure that the specification is available at the given URI");
        }

        final RestDslYamlGenerator generator = RestDslGenerator.toYaml(openapi);

        if (ObjectHelper.isNotEmpty(basePath)) {
            generator.withBasePath(basePath);
        }

        if (ObjectHelper.isNotEmpty(filterOperation)) {
            generator.withOperationFilter(filterOperation);
        }
        if (dto) {
            if (modelPackage != null) {
                generator.withDtoPackageName(modelPackage);
            }
        }

        if (ObjectHelper.isNotEmpty(destinationGenerator)) {
            final DestinationGenerator destinationGeneratorObject = createDestinationGenerator();
            generator.withDestinationGenerator(destinationGeneratorObject);
        } else if (ObjectHelper.isNotEmpty(destinationToSyntax)) {
            generator.withDestinationToSyntax(destinationToSyntax);
        }

        if (restConfiguration) {
            generator.withRestComponent(findAppropriateComponent());
            if (clientRequestValidation) {
                generator.withClientRequestValidation();
            }
            if (ObjectHelper.isNotEmpty(apiContextPath)) {
                generator.withApiContextPath(apiContextPath);
            }
        }

        try {
            final CamelContext camel = new DefaultCamelContext();
            final String yaml = generator.generate(camel);

             
            new File(outputDirectory).mkdirs();
            final File out = new File(outputDirectory, fileName);

            try (FileOutputStream fos = new FileOutputStream(out)) {
                fos.write(yaml.getBytes());
            }
        } catch (final Exception e) {
            throw new MojoExecutionException(
                    "Unable to generate REST DSL OpenApi sources from specification: " + specificationUri, e);
        }
    }

    protected List<Configurer<SSLSocketFactory>> getSSLSocketFactoryConfigurers(SSLContext context) {

        final List<Configurer<SSLSocket>> sslSocketConfigurers = this.getSSLSocketFactorySSLSocketConfigurers(context);

        Configurer<SSLSocketFactory> sslSocketFactoryConfigurer = new Configurer<>() {

            @Override
            public SSLSocketFactory configure(SSLSocketFactory factory) {
                return new SSLSocketFactoryDecorator(
                        factory,
                        sslSocketConfigurers);
            }
        };

        List<Configurer<SSLSocketFactory>> sslSocketFactoryConfigurers = new LinkedList<>();
        sslSocketFactoryConfigurers.add(sslSocketFactoryConfigurer);

        return sslSocketFactoryConfigurers;
    }

        protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
            doBeforeParse(element);
            super.doParse(element, parserContext, builder);

             
            Binder<Node> binder;
            try {
                binder = getJaxbContext().createBinder();
            } catch (JAXBException e) {
                throw new BeanDefinitionStoreException("Failed to create the JAXB binder", e);
            }
            Object value = parseUsingJaxb(element, parserContext, binder);

            if (value instanceof CamelRestContextFactoryBean) {
                CamelRestContextFactoryBean factoryBean = (CamelRestContextFactoryBean) value;
                builder.addPropertyValue("rests", factoryBean.getRests());
            }

             
            injectNamespaces(element, binder);
        }

    protected void doShowTags(Exchange exchange, String operation) throws GitAPIException {
        List<Ref> result = null;
        try {
            result = git.tagList().call();
        } catch (GitAPIException e) {
            LOG.error("There was an error in Git {} operation", operation);
            throw e;
        }
        updateExchange(exchange, result);
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.embedded.InfinispanEmbeddedProducer target = (org.apache.camel.component.infinispan.embedded.InfinispanEmbeddedProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    private void addDocument(Exchange exchange) {
        Discovery discovery = getEndpoint().getDiscoveryClient();
        String projectId = getEndpoint().getConfiguration().getProjectId();

        String collectionId = exchange.getIn().getHeader(WatsonDiscoveryConstants.COLLECTION_ID, String.class);
        if (collectionId == null) {
            collectionId = getEndpoint().getConfiguration().getCollectionId();
        }

        if (collectionId == null) {
            throw new IllegalArgumentException("Collection ID must be specified");
        }

        InputStream file = exchange.getIn().getHeader(WatsonDiscoveryConstants.DOCUMENT_FILE, InputStream.class);
        if (file == null) {
            file = exchange.getIn().getBody(InputStream.class);
        }

        if (file == null) {
            throw new IllegalArgumentException("Document file must be specified");
        }

        String filename = exchange.getIn().getHeader(WatsonDiscoveryConstants.DOCUMENT_FILENAME, String.class);
        if (filename == null) {
            filename = "document";
        }

        String contentType = exchange.getIn().getHeader(WatsonDiscoveryConstants.DOCUMENT_CONTENT_TYPE, String.class);
        if (contentType == null) {
            contentType = "application/octet-stream";
        }

        LOG.trace("Adding document to collection: {}", collectionId);

        AddDocumentOptions options = new AddDocumentOptions.Builder()
                .projectId(projectId)
                .collectionId(collectionId)
                .file(file)
                .filename(filename)
                .fileContentType(contentType)
                .build();

        DocumentAccepted result = discovery.addDocument(options).execute().getResult();

        Message message = getMessageForResponse(exchange);
        message.setBody(result);
        message.setHeader(WatsonDiscoveryConstants.DOCUMENT_ID, result.getDocumentId());
    }

    protected void copyMavenWrapper() throws Exception {
        Path wrapperPath = Paths.get(BUILD_DIR, ".mvn/wrapper");
        Files.createDirectories(wrapperPath);
         
        Path mvnwPath = Paths.get(BUILD_DIR, "mvnw");
        Path mvnwCmdPath = Paths.get(BUILD_DIR, "mvnw.cmd");
        Path wrapperJarPath = wrapperPath.resolve("maven-wrapper.jar");
        Path wrapperPropsPath = wrapperPath.resolve("maven-wrapper.properties");

        try (InputStream is = ExportBaseCommand.class.getClassLoader().getResourceAsStream("maven-wrapper/mvnw")) {
            Files.copy(is, mvnwPath, StandardCopyOption.REPLACE_EXISTING);
        }
        try (InputStream is = ExportBaseCommand.class.getClassLoader().getResourceAsStream("maven-wrapper/mvnw.cmd")) {
            Files.copy(is, mvnwCmdPath, StandardCopyOption.REPLACE_EXISTING);
        }
        try (InputStream is = ExportBaseCommand.class.getClassLoader().getResourceAsStream("maven-wrapper/maven-wrapper.jar")) {
            Files.copy(is, wrapperJarPath, StandardCopyOption.REPLACE_EXISTING);
        }
        try (InputStream is
                = ExportBaseCommand.class.getClassLoader().getResourceAsStream("maven-wrapper/maven-wrapper.properties")) {
            Files.copy(is, wrapperPropsPath, StandardCopyOption.REPLACE_EXISTING);
        }

         
        FileUtil.setPosixFilePermissions(mvnwPath, "rwxr-xr-x");
        FileUtil.setPosixFilePermissions(mvnwCmdPath, "rwxr-xr-x");
    }

    public String apply(String remainder) {
        String key = remainder;
        String defaultValue = null;

        if (remainder.contains(":")) {
            key = StringHelper.before(remainder, ":");
            defaultValue = StringHelper.after(remainder, ":");
        }

        String value = System.getProperty(key);
        return value != null ? value : defaultValue;
    }

    protected void ensureNamespacesCapacity(int size) {
        final int namespaceSize = namespacePrefix != null ? namespacePrefix.length : 0;
        if (size >= namespaceSize) {
            final int newSize = size > 7 ? 2 * size : 8;  
            if (TRACE_SIZING) {
                System.err.println("TRACE_SIZING namespaceSize " + namespaceSize + " ==> " + newSize);
            }
            final String[] newNamespacePrefix = new String[newSize];
            final String[] newNamespaceUri = new String[newSize];
            if (namespacePrefix != null) {
                System.arraycopy(namespacePrefix, 0, newNamespacePrefix, 0, namespaceEnd);
                System.arraycopy(namespaceUri, 0, newNamespaceUri, 0, namespaceEnd);
            }
            namespacePrefix = newNamespacePrefix;
            namespaceUri = newNamespaceUri;

            if (!allStringsInterned) {
                final int[] newNamespacePrefixHash = new int[newSize];
                if (namespacePrefixHash != null) {
                    System.arraycopy(namespacePrefixHash, 0, newNamespacePrefixHash, 0, namespaceEnd);
                }
                namespacePrefixHash = newNamespacePrefixHash;
            }
             
             
        }
    }

    protected int poll() throws Exception {
        Object feed = createFeed();
        if (feed != null) {
            Exchange exchange = endpoint.createExchange(feed);
            getProcessor().process(exchange);
            return 1;
        } else {
            return 0;
        }
    }

    public void transform(Message message, DataType fromType, DataType toType) {
        final Map<String, Object> headers = message.getHeaders();

        CloudEvent cloudEvent = CloudEvents.v1_0;
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_ID, message.getExchange().getExchangeId());
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_VERSION, cloudEvent.version());
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TYPE, "org.apache.camel.event.azure.eventhubs.consume");

        if (message.getHeaders().containsKey(EventHubsConstants.PARTITION_ID)) {
            headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SOURCE,
                    "azure.eventhubs." + message.getHeader(EventHubsConstants.PARTITION_ID, String.class));
        }

        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SUBJECT, message.getHeader(EventHubsConstants.SEQUENCE_NUMBER, Long.class));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TIME, cloudEvent.getEventTime(message.getExchange()));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_CONTENT_TYPE, CloudEvent.APPLICATION_OCTET_STREAM_MIME_TYPE);
    }

    public String extractText(String chunk) throws JsonProcessingException {
        if (chunk == null || chunk.trim().isEmpty()) {
            return "";
        }
        JsonNode node = MAPPER.readTree(chunk);
        JsonNode outputs = node.get("outputs");
        if (outputs != null && outputs.isArray() && outputs.size() > 0) {
            JsonNode firstOutput = outputs.get(0);
            JsonNode text = firstOutput.get("text");
            return text != null && !text.isNull() ? text.asText() : "";
        }
        return "";
    }

    public static void setIn(Exchange exchange, Object payload) {
        if (payload instanceof DefaultExchangeHolder) {
            DefaultExchangeHolder.unmarshal(exchange, (DefaultExchangeHolder) payload);
        } else if (payload instanceof AddressedEnvelope) {
            @SuppressWarnings("unchecked")
            AddressedEnvelope<Object, InetSocketAddress> dp = (AddressedEnvelope<Object, InetSocketAddress>) payload;
             
            if (dp.content() instanceof DefaultExchangeHolder) {
                DefaultExchangeHolder.unmarshal(exchange, (DefaultExchangeHolder) dp.content());
            } else {
                 
                exchange.getIn().setBody(dp.content());
            }
             
            exchange.setProperty(NettyConstants.NETTY_REMOTE_ADDRESS, dp.sender());
             
            exchange.getIn().setHeader(NettyConstants.NETTY_REMOTE_ADDRESS, dp.sender());
        } else {
             
            exchange.getIn().setBody(payload);
        }
    }

    protected void doStart() throws Exception {
        if (isServiceLocationEnabled()) {
             
            BeanIntrospection bi = PluginHelper.getBeanIntrospection(getCamelContext());
            DataSource ds = getDataSource();
             
            if (ds != null && ds.getClass().getName().endsWith("ClientProxy")) {
                DataSource actual = UnwrapHelper.unwrapClientProxy(ds);
                if (actual != null) {
                    ds = actual;
                }
            }
            serviceUrl = SqlServiceLocationHelper.getJDBCURLFromDataSource(bi, ds);

            serviceMetadata = new HashMap<>();
            String user = SqlServiceLocationHelper.getUsernameFromConnectionFactory(bi, ds);
            if (user != null) {
                serviceMetadata.put("username", user);
            }
        }
    }

    private static List<String> gatherEnums(UriParam param, Class<?> fieldTypeElement) {
        if (!Strings.isNullOrEmpty(param.enums())) {
            String[] values = param.enums().split(",");
            return Stream.of(values).map(String::trim).toList();
        } else if (fieldTypeElement.isEnum()) {
            return doGatherFromEnum(fieldTypeElement);
        }

        return null;
    }

private int jjMoveStringLiteralDfa1_0(long active0){
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(0, active0);
      return 1;
   }
   switch(curChar)
   {
      case 78:
         return jjMoveStringLiteralDfa2_0(active0, 0x8L);
      case 85:
         return jjMoveStringLiteralDfa2_0(active0, 0x4L);
      default :
         break;
   }
   return jjStartNfa_0(0, active0);
}

    private static String getOutTypeName(String outType, Class<?> outTypeClass, String typeName) {
        String outTypeName = null;
        if (outTypeClass != null) {
            outTypeName = outTypeClass.isArray() ? outTypeClass.getComponentType().getName() : outTypeClass.getName();
        } else if (outType != null) {
            outTypeName = outType.endsWith("[]") ? outType.substring(0, outType.length() - 2) : outType;
        } else if (typeName != null) {
             
            outTypeName = typeName;
        }
        return outTypeName;
    }

    protected void doStop() throws Exception {
        super.doStop();

        LOG.debug("Stopping Kubernetes Namespace Consumer");
        if (executor != null) {
            KubernetesHelper.close(nsWatcher, nsWatcher::getWatch);

            if (getEndpoint() != null && getEndpoint().getCamelContext() != null) {
                getEndpoint().getCamelContext().getExecutorServiceManager().shutdownNow(executor);
            } else {
                executor.shutdownNow();
            }
        }
        executor = null;
    }

    private void doUpsert(Exchange exchange, String tableName) throws KuduException {
        LOG.trace("Upsert on table {}", tableName);
        KuduClient connection = endpoint.getKuduClient();
        KuduTable table = connection.openTable(tableName);

        Upsert upsert = table.newUpsert();
        PartialRow row = upsert.getRow();

        Map<?, ?> rows = exchange.getIn().getBody(Map.class);
        for (Map.Entry<?, ?> entry : rows.entrySet()) {
            final String colName = entry.getKey().toString();
            final Object value = entry.getValue();
            if (table.getSchema().getColumn(colName) != null) {
                row.addObject(colName, value);
            }
        }

        connection.newSession().apply(upsert);
    }

    public void close() {
        if (!closed) {
            try {
                ClearScrollRequest clearScrollRequest = new ClearScrollRequest.Builder()
                        .scrollId(List.of(scrollId))
                        .build();

                esClient.clearScroll(clearScrollRequest);
                closed = true;
                exchange.setProperty(OpensearchConstants.PROPERTY_SCROLL_OPENSEARCH_QUERY_COUNT, requestCount);
            } catch (IOException e) {
                throw new IllegalStateException(e);
            }
        }
    }

    public ElasticsearchScrollRequestIterator(SearchRequest.Builder searchRequestBuilder, ElasticsearchClient esClient,
                                              int scrollKeepAliveMs, Exchange exchange, Class<TDocument> documentClass) {
         
        this.searchRequest = searchRequestBuilder
                .scroll(Time.of(b -> b.time(String.format("%sms", scrollKeepAliveMs))))
                .build();
        this.esClient = esClient;
        this.scrollKeepAliveMs = scrollKeepAliveMs;
        this.exchange = exchange;
        this.closed = false;
        this.requestCount = 0;
        this.documentClass = documentClass;

        setFirstCurrentSearchHits();
    }

    private TagImageCmd executeTagImageRequest(DockerClient client, Message message) {

        LOGGER.debug("Executing Docker Tag Image Request");

        String imageId = DockerHelper.getProperty(DockerConstants.DOCKER_IMAGE_ID, configuration, message, String.class);

        String repository = DockerHelper.getProperty(DockerConstants.DOCKER_REPOSITORY, configuration, message, String.class);

        String tag = DockerHelper.getProperty(DockerConstants.DOCKER_TAG, configuration, message, String.class);

        if (imageId == null || repository == null || tag == null) {
            throw new IllegalArgumentException("ImageId, repository and tag must be specified");
        }

        TagImageCmd tagImageCmd = client.tagImageCmd(imageId, repository, tag);

        Boolean force = DockerHelper.getProperty(DockerConstants.DOCKER_FORCE, configuration, message, Boolean.class);

        if (force != null) {
            tagImageCmd.withForce(force);
        }

        return tagImageCmd;

    }

    public void onDataFormatCreated(String name, DataFormat dataFormat) {
        Registry registry = this.camelContext.getRegistry();
        if (registry == null) {
            return;
        }

        Set<DataFormatCustomizer.Policy> filters = registry.findByType(DataFormatCustomizer.Policy.class);
        if (filters.isEmpty() || filters.stream().allMatch(filter -> filter.test(name, dataFormat))) {
            registry.findByType(DataFormatCustomizer.class).stream()
                    .sorted(Comparator.comparingInt(Ordered::getOrder))
                    .filter(customizer -> customizer.isEnabled(name, dataFormat))
                    .forEach(customizer -> customizer.configure(name, dataFormat));
        }
    }

    private void userSelectedPropertiesMDC(Exchange exchange, boolean push) {
        for (String customProperty : getCustomProperties().split(",")) {
            if (exchange.getProperty(customProperty) != null) {
                if (push) {
                    MDC.put(customProperty, exchange.getProperty(customProperty, String.class));
                } else {
                    MDC.remove(customProperty);
                }
            }
        }
    }

    public void beforeTracingEvent(Span span, Exchange exchange, Endpoint endpoint) {
        super.beforeTracingEvent(span, exchange, endpoint);

        String partition = getValue(exchange, PARTITION, Integer.class);
        if (partition != null) {
            span.setTag(KAFKA_PARTITION_TAG, partition);
        }

        String partitionKey = exchange.getIn().getHeader(PARTITION_KEY, String.class);
        if (partitionKey != null) {
            span.setTag(KAFKA_PARTITION_KEY_TAG, partitionKey);
        }

        String key = exchange.getIn().getHeader(KEY, String.class);
        if (key != null) {
            span.setTag(KAFKA_KEY_TAG, key);
        }

        String offset = getValue(exchange, OFFSET, String.class);
        if (offset != null) {
            span.setTag(KAFKA_OFFSET_TAG, offset);
        }
    }

    public static void setField(Field f, Object instance, Object value) {
        try {
            boolean oldAccessible = f.canAccess(instance);
            boolean shouldSetAccessible = !Modifier.isPublic(f.getModifiers()) && !oldAccessible;
            if (shouldSetAccessible) {
                f.setAccessible(true);
            }
            f.set(instance, value);
            if (shouldSetAccessible) {
                f.setAccessible(oldAccessible);
            }
        } catch (IllegalArgumentException ex) {
            throw new UnsupportedOperationException("Cannot inject value of class: " + value.getClass() + " into: " + f);
        } catch (IllegalAccessException ex) {
            handleReflectionException(ex);
        }
    }

        public void onComplete(final Exchange exchange) {
            if (shouldSkip(exchange, onFailureOnly)) {
                return;
            }

             
            final Exchange copy = prepareExchange(exchange);

            if (executorService != null) {
                Runnable task = () -> {
                    LOG.debug("Processing onComplete: {}", copy);
                    doProcess(processor, copy);
                };
                task = prepareMDCParallelTask(camelContext, task);
                executorService.submit(task);
            } else {
                 
                LOG.debug("Processing onComplete: {}", copy);
                doProcess(processor, copy);
            }
        }

    public int processBatch(Queue<Object> exchanges) throws Exception {
        int total = exchanges.size();
        int answer = total;
        if (this.maxMessagesPerPoll > 0 && total > this.maxMessagesPerPoll) {
            LOG.debug("Limiting to maximum messages to poll {} as there were {} messages in this poll.",
                    this.maxMessagesPerPoll, total);
            total = this.maxMessagesPerPoll;
        }

        for (int index = 0; index < total && this.isBatchAllowed(); ++index) {
            Exchange exchange = (Exchange) exchanges.poll();
            exchange.setProperty(ExchangePropertyKey.BATCH_INDEX, index);
            exchange.setProperty(ExchangePropertyKey.BATCH_SIZE, total);
            exchange.setProperty(ExchangePropertyKey.BATCH_COMPLETE, index == total - 1);
            this.pendingExchanges = total - index - 1;
            Object value = onPreProcessed(exchange);
            getProcessor().process(exchange);
            onProcessed(exchange, value);
        }

        return answer;
    }

    private Exception createExceptionFromFault(String soapAction, Fault fault) {
        String message = fault.getFaultstring();

        Detail faultDetail = fault.getDetail();
        if (faultDetail == null || faultDetail.getAny().isEmpty()) {
            try {
                return new SOAPFaultException(SOAPFactory.newInstance().createFault(message, fault.getFaultcode()));
            } catch (SOAPException e) {
                throw new RuntimeCamelException(e);
            }
        }

        Object detailObj = faultDetail.getAny().get(0);

        if (!(detailObj instanceof JAXBElement)) {
            try {
                return new SOAPFaultException(SOAPFactory.newInstance().createFault(message, fault.getFaultcode()));
            } catch (SOAPException e) {
                throw new RuntimeCamelException(e);
            }
        }

        JAXBElement<?> detailEl = (JAXBElement<?>) detailObj;
        Class<? extends Exception> exceptionClass
                = getDataFormat().getElementNameStrategy().findExceptionForSoapActionAndFaultName(soapAction,
                        detailEl.getName());
        Constructor<? extends Exception> messageConstructor;
        Constructor<? extends Exception> constructor;

        try {
            Object detail = JAXBIntrospector.getValue(detailEl);
            try {
                constructor = exceptionClass.getConstructor(String.class, detail.getClass());
                return constructor.newInstance(message, detail);
            } catch (NoSuchMethodException e) {
                messageConstructor = exceptionClass.getConstructor(String.class);
                return messageConstructor.newInstance(message);
            }
        } catch (Exception e) {
            throw new RuntimeCamelException(e);
        }
    }

    protected void doStart() throws Exception {
        super.doStart();
        try {
            plc4XEndpoint.setupConnection();
        } catch (PlcConnectionException e) {
            if (LOGGER.isTraceEnabled()) {
                LOGGER.error("Connection setup failed, stopping PollingConsumer", e);
            } else {
                LOGGER.error("Connection setup failed, stopping PollingConsumer");
            }
            doStop();
        }
    }

    public static Object deserializeJavaObjectFromStream(InputStream is) throws ClassNotFoundException, IOException {
        if (is == null) {
            return null;
        }

        Object answer = null;
        ObjectInputStream ois = new ObjectInputStream(is);
        try {
            answer = ois.readObject();
        } finally {
            IOHelper.close(ois);
        }

        return answer;
    }

    private boolean sleep() {
        LOG.trace("Exclusive read lock not granted. Sleeping for {} millis.", checkInterval);
        try {
            Thread.sleep(checkInterval);
            return false;
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            LOG.debug("Sleep interrupted while waiting for exclusive read lock, so breaking out");
            return true;
        }
    }

        public Olingo4BatchChangeRequest build() {
             
            if (request.resourcePath == null) {
                throw new IllegalArgumentException("Null resourcePath");
            }
            if (request.operation == null) {
                throw new IllegalArgumentException("Null operation");
            }
            if (request.operation != Operation.DELETE && request.body == null) {
                throw new IllegalArgumentException("Null body");
            }
            return request;
        }

    protected JsonObject doCallJson(Map<String, Object> options) {
        JsonObject root = new JsonObject();
        if (propertiesFunction != null) {
            root.put("masterUrl", propertiesFunction.getClient().getMasterUrl().toString());
            root.put("login", "OAuth Token");
        }
        KubernetesVaultConfiguration kubernetes = getCamelContext().getVaultConfiguration().getKubernetesVaultConfiguration();
        if (kubernetes != null) {
            root.put("refreshEnabled", kubernetes.isRefreshEnabled());
        }
        if (cmRefreshTask != null) {
            Instant start = cmRefreshTask.getStartingTime();
            if (start != null) {
                long timestamp = start.toEpochMilli();
                root.put("startCheckTimestamp", timestamp);
            }
        }
        JsonArray arr = new JsonArray();
        root.put("configmaps", arr);

        List<String> sorted = new ArrayList<>(List.of(kubernetes.getSecrets().split(",")));
        Collections.sort(sorted);

        for (String sec : sorted) {
            JsonObject jo = new JsonObject();
            jo.put("name", sec);
            arr.add(jo);
        }
        return root;
    }

    protected boolean acceptResource(Resource resource) {
        String loc = resource.getLocation();
        if (loc == null) {
            return false;
        }

         
        if (loc.endsWith("context-check")) {
            return false;
        }

        return true;
    }

    protected String doCallText(Map<String, Object> options) {
        StringBuilder sb = new StringBuilder();

        if (propertiesFunction != null) {
            sb.append("Kubernetes Config maps Cluster:");
            sb.append(String.format("\n    Master Url: %s", propertiesFunction.getClient().getMasterUrl()));
            sb.append("\n    Login: OAuth Token");
            KubernetesVaultConfiguration kubernetes
                    = getCamelContext().getVaultConfiguration().getKubernetesVaultConfiguration();
            if (kubernetes != null) {
                sb.append(String.format("\n    Refresh Enabled: %s", kubernetes.isRefreshEnabled()));
            }
            if (cmRefreshTask != null) {
                Instant start = cmRefreshTask.getStartingTime();
                String s = start != null ? TimeUtils.printSince(start.toEpochMilli()) : "none";
                sb.append(String.format("\n    Running Since: %s", s));
            }
            List<String> sorted = new ArrayList<>();
            if (kubernetes != null) {
                sb.append("\n\nSecrets in use:");

                sorted = new ArrayList<>(List.of(kubernetes.getSecrets().split(",")));
                Collections.sort(sorted);
            }

            for (String sec : sorted) {
                sb.append(String.format("\n    %s", sec));
            }
        }

        return sb.toString();
    }

    protected void doList(Exchange exchange) {
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        ServiceAccountList saList;

        if (ObjectHelper.isEmpty(namespace)) {
            saList = getEndpoint().getKubernetesClient().serviceAccounts().inAnyNamespace().list();
        } else {
            saList = getEndpoint().getKubernetesClient().serviceAccounts().inNamespace(namespace).list();
        }

        prepareOutboundMessage(exchange, saList.getItems());
    }

    protected boolean isBanned(ClassInfo ci) {
        if (bannedDefinitions != null) {
            for (String bannedDefinition : bannedDefinitions) {
                if (AntPathMatcher.INSTANCE.match(bannedDefinition.replace('.', '/'), ci.name().toString('/'))) {
                    getLog().debug("Skipping definition: " + ci.name().toString());
                    return true;
                }
            }
        }

        return false;
    }

    public ZipIterator(Exchange exchange, InputStream inputStream) {
        this.exchange = exchange;
        this.allowEmptyDirectory = false;

        Objects.requireNonNull(inputStream);

        if (inputStream instanceof ZipArchiveInputStream) {
            zipInputStream = (ZipArchiveInputStream) inputStream;
        } else {
            try {
                ArchiveInputStream input = new ArchiveStreamFactory().createArchiveInputStream(ArchiveStreamFactory.ZIP,
                        new BufferedInputStream(inputStream));
                zipInputStream = (ZipArchiveInputStream) input;
            } catch (ArchiveException e) {
                throw new RuntimeException(e.getMessage(), e);
            }
        }
        parent = null;
        first = true;
    }

    public void deregister(ServiceDefinition definition) {
        if (definition.getId() == null) {
            throw new IllegalArgumentException("Service ID must be defined (definition=" + definition + ")");
        }
        if (definition.getName() == null) {
            throw new IllegalArgumentException("Service Name must be defined (definition=" + definition + ")");
        }

        try {
            for (ServiceInstance<MetaData> serviceInstance : serviceDiscovery.queryForInstances(definition.getName())) {
                if (Objects.equals(serviceInstance.getId(), definition.getId())) {
                    serviceDiscovery.unregisterService(serviceInstance);

                     
                    serviceList.remove(serviceInstance.getId());
                }
            }
        } catch (Exception e) {
            LOGGER.warn("{}", e.getMessage(), e);
        }
    }

    private FTPFile[] getFtpFiles(String dir) {
        FTPFile[] files = null;
        try {
            LOG.trace("Polling directory: {}", dir);
            if (isUseList()) {
                files = listFiles(dir);
            } else {
                files = pollNamedFile();
            }
        } catch (GenericFileOperationFailedException e) {
            if (ignoreCannotRetrieveFile(null, null, e)) {
                LOG.debug("Cannot list files in directory {} due directory does not exist or file permission error.", dir);
            } else {
                throw e;
            }
        }
        return files;
    }

    public void invalidRecord(InvalidRecordException ex) throws Exception {
        String msg = LOG_PREFIX + "InvalidRecord: " + ex.getMessage() + ": " + ex.getRecordContext().getRecordText();
        if (getConfiguration().isIgnoreInvalidRecords()) {
            LOG.debug(msg);
        } else {
            LOG.warn(msg);
            throw ex;
        }
    }

    private void processDeleteSobjectWithId(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {
        String sObjectName = determineSObjectName(exchange);
        final String sObjectExtIdName = getParameter(SOBJECT_EXT_ID_NAME, exchange, IGNORE_BODY, NOT_OPTIONAL);

         
        Object oldValue = null;
        final AbstractSObjectBase sObjectBase = exchange.getIn().getBody(AbstractSObjectBase.class);
        String sObjectExtIdValue;
        if (sObjectBase != null) {
            oldValue = getAndClearPropertyValue(sObjectBase, sObjectExtIdName);
            sObjectExtIdValue = oldValue.toString();
        } else {
            sObjectExtIdValue = getParameter(SOBJECT_EXT_ID_VALUE, exchange, USE_BODY, NOT_OPTIONAL);
        }

        final Object finalOldValue = oldValue;
        restClient.deleteSObjectWithId(sObjectName, sObjectExtIdName, sObjectExtIdValue, determineHeaders(exchange),
                new RestClient.ResponseCallback() {
                    @Override
                    public void onResponse(InputStream response, Map<String, String> headers, SalesforceException exception) {
                        processResponse(exchange, response, headers, exception, callback);
                        restoreFields(exchange, sObjectBase, null, sObjectExtIdName, finalOldValue);
                    }
                });
    }

        void add(FileInputStreamCache fileInputStreamCache) {
            lock.lock();
            try {
                if (fileInputStreamCaches == null) {
                    fileInputStreamCaches = new ArrayList<>(3);
                }
                fileInputStreamCaches.add(fileInputStreamCache);
            } finally {
                lock.unlock();
            }
        }

    public Task schedule(BackOff backOff, ThrowingFunction<Task, Boolean, Exception> function) {
        final BackOffTimerTask task = new BackOffTimerTask(this, backOff, scheduler, function);

        long delay = task.next();
        if (delay != BackOff.NEVER) {
            tasks.add(task);
            scheduler.schedule(task, delay, TimeUnit.MILLISECONDS);
        } else {
            task.cancel();
        }

        return task;
    }

    private <REQ, RES> void executeOperation(
            Exchange exchange,
            Class<REQ> requestClass,
            Function<REQ, RES> pojoExecutor,
            Supplier<RES> headerExecutor,
            String operationName,
            BiConsumer<RES, Message> responseProcessor)
            throws InvalidPayloadException {

        RES result;
        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (requestClass.isInstance(payload)) {
                try {
                    result = pojoExecutor.apply(requestClass.cast(payload));
                } catch (AwsServiceException ase) {
                    LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                    throw ase;
                }
                LOG.trace("{} request performing", operationName);
            } else {
                throw new IllegalArgumentException(
                        String.format("Expected body of type %s but was %s",
                                requestClass.getName(),
                                payload != null ? payload.getClass().getName() : "null"));
            }
        } else {
            try {
                result = headerExecutor.get();
            } catch (AwsServiceException ase) {
                LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                throw ase;
            }
        }
        Message message = getMessageForResponse(exchange);
        message.setBody(result);
        if (responseProcessor != null) {
            responseProcessor.accept(result, message);
        }
    }

    protected void doStart() throws Exception {
        super.doStart();

        connectionOptions = getEndpoint().createMqttConnectionOptions();

        if (client == null) {
            clientId = getEndpoint().getConfiguration().getClientId();
            if (clientId == null) {
                clientId = PahoMqtt5Endpoint.generateClientId();
            }
            stopClient = true;
            client = new MqttClient(
                    getEndpoint().getConfiguration().getBrokerUrl(),
                    clientId,
                    PahoMqtt5Endpoint.createMqttClientPersistence(getEndpoint().getConfiguration()));
            LOG.debug("Connecting client: {} to broker: {}", clientId, getEndpoint().getConfiguration().getBrokerUrl());
            if (getEndpoint().getConfiguration().isManualAcksEnabled()) {
                client.setManualAcks(true);

            }
            client.connect(connectionOptions);
        }

        client.setCallback(new MqttCallback() {

            @Override
            public void connectComplete(boolean reconnect, String serverURI) {
                if (reconnect) {
                    try {
                        client.subscribe(getEndpoint().getTopic(), getEndpoint().getConfiguration().getQos());
                    } catch (MqttException e) {
                        LOG.error("MQTT resubscribe failed {}", e.getMessage(), e);
                    }
                }
            }

            @Override
            public void authPacketArrived(int reasonCode, MqttProperties properties) {
                LOG.debug("Auth packet arrived {} {}", reasonCode, properties);
            }

            @Override
            public void disconnected(MqttDisconnectResponse response) {
                LOG.debug("MQTT broker disconnected due {}", response.getReasonString(), response.getException());
            }

            @Override
            public void mqttErrorOccurred(MqttException exception) {
                LOG.debug("Error occurred {}", exception.getMessage(), exception);
            }

            @Override
            public void messageArrived(String topic, MqttMessage message) throws Exception {
                LOG.debug("Message arrived on topic: {} -> {}", topic, message);
                Exchange exchange = createExchange(message, topic);

                 
                AsyncCallback cb = defaultConsumerCallback(exchange, true);
                getAsyncProcessor().process(exchange, cb);
            }

            @Override
            public void deliveryComplete(IMqttToken token) {
                LOG.debug("Delivery complete. Token: {}", token);
            }
        });

        LOG.debug("Subscribing client: {} to topic: {}", clientId, getEndpoint().getTopic());
        client.subscribe(getEndpoint().getTopic(), getEndpoint().getConfiguration().getQos());
    }

    public void onDownloadComplete(String host, String file) {
        String prefix = resume ? "Resume downloading" : "Downloading";
        String msg = prefix + " from host: " + host + " file: " + file + " completed";
        if (transferredBytes > 0) {
            msg += " (size: " + StringHelper.humanReadableBytes(transferredBytes) + ")";
        }
        long taken = watch.taken();
        String time = TimeUtils.printDuration(taken, true);
        msg += " (took: " + time + ")";
        doLog(msg);
    }

    public Exchange add(CamelContext camelContext, String key, Exchange oldExchange, Exchange newExchange)
            throws OptimisticLockingException {
        if (!optimistic) {
            throw new UnsupportedOperationException();
        }

        LOG.trace("Adding an Exchange with ID {} for key {} in an optimistic manner.", newExchange.getExchangeId(), key);
        if (oldExchange == null) {
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            DefaultExchangeHolder oldHolder = cache.getAndPut(key, newHolder);
            if (oldHolder != null) {
                Exchange exchange = unmarshallExchange(camelContext, oldHolder);
                LOG.error(
                        "Optimistic locking failed for exchange with key {}: IMap#putIfAbsend returned Exchange with ID {}, while it's expected no exchanges to be returned",
                        key,
                        exchange != null ? exchange.getExchangeId() : "<null>");

                throw new OptimisticLockingException();
            }
        } else {
            DefaultExchangeHolder oldHolder = DefaultExchangeHolder.marshal(oldExchange, true, allowSerializedHeaders);
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            if (!cache.replace(key, oldHolder, newHolder)) {
                LOG.error(
                        "Optimistic locking failed for exchange with key {}: IMap#replace returned no Exchanges, while it's expected to replace one",
                        key);
                throw new OptimisticLockingException();
            }
        }
        LOG.trace("Added an Exchange with ID {} for key {} in optimistic manner.", newExchange.getExchangeId(), key);
        return oldExchange;
    }

    private static String getOutTypeName(String outType, Class<?> outTypeClass, String typeName) {
        String outTypeName = null;
        if (outTypeClass != null) {
            outTypeName = outTypeClass.isArray() ? outTypeClass.getComponentType().getName() : outTypeClass.getName();
        } else if (outType != null) {
            outTypeName = outType.endsWith("[]") ? outType.substring(0, outType.length() - 2) : outType;
        } else if (typeName != null) {
             
            outTypeName = typeName;
        }
        return outTypeName;
    }

    List<Row> collectRows() {
        List<Row> rows = new ArrayList<>();
        for (String name : catalog.findDataFormatNames()) {
            DataFormatModel model = catalog.dataFormatModel(name);
            if (model != null) {
                Row row = new Row();
                row.name = model.getName();
                row.title = model.getTitle();
                row.level = model.getSupportLevel().name();
                row.since = fixQuarkusSince(model.getFirstVersionShort());
                row.description = model.getDescription();
                row.label = model.getLabel() != null ? model.getLabel() : "";
                row.deprecated = model.isDeprecated();
                row.nativeSupported = model.isNativeSupported();
                row.gav = getGAV(model);
                rows.add(row);
            }
        }
        return rows;
    }

    public KeyPair generateKeyPair(String algorithm, String keyId, Object parameterSpec) throws Exception {
        LOG.info("Generating key pair for algorithm: {}, keyId: {}", algorithm, keyId);

        KeyPairGenerator generator;
        String provider = determineProvider(algorithm);

        if (provider != null) {
            generator = KeyPairGenerator.getInstance(getAlgorithmName(algorithm), provider);
        } else {
            generator = KeyPairGenerator.getInstance(getAlgorithmName(algorithm));
        }

         
        if (parameterSpec != null) {
            if (parameterSpec instanceof AlgorithmParameterSpec) {
                generator.initialize((AlgorithmParameterSpec) parameterSpec, new SecureRandom());
            } else if (parameterSpec instanceof Integer) {
                generator.initialize((Integer) parameterSpec, new SecureRandom());
            }
        } else {
             
            AlgorithmParameterSpec defaultSpec = getDefaultParameterSpec(algorithm);
            if (defaultSpec != null) {
                generator.initialize(defaultSpec, new SecureRandom());
            } else {
                generator.initialize(getDefaultKeySize(algorithm), new SecureRandom());
            }
        }

        KeyPair keyPair = generator.generateKeyPair();

         
        KeyMetadata metadata = new KeyMetadata(keyId, algorithm);
        metadata.setDescription("Generated on " + new Date());

         
        storeKey(keyId, keyPair, metadata);

        LOG.info("Generated key pair in Vault: {}", metadata);
        return keyPair;
    }

    List<CatalogBaseCommand.Row> collectRows() {
        List<Row> rows = new ArrayList<>();
        for (String name : findComponentNames(catalog)) {
            ComponentModel model = catalog.componentModel(name);
            if (model != null) {
                Row row = new Row();
                row.name = model.getScheme();
                row.title = model.getTitle();
                row.level = model.getSupportLevel().name();
                row.since = fixQuarkusSince(model.getFirstVersionShort());
                row.description = model.getDescription();
                row.label = model.getLabel() != null ? model.getLabel() : "";
                row.deprecated = model.isDeprecated();
                row.nativeSupported = model.isNativeSupported();
                row.gav = getGAV(model);
                rows.add(row);
            }
        }
        return rows;
    }

    private int doRunDebugSpringBoot(KameletMain main) throws Exception {
        Path pom = Paths.get("pom.xml");
        MavenXpp3Reader mavenReader = new MavenXpp3Reader();
        try (Reader reader = Files.newBufferedReader(pom)) {
            Model model = mavenReader.read(reader);

             
            Dependency d = new Dependency();
            d.setGroupId("org.apache.camel.springboot");
            d.setArtifactId("camel-debug-starter");
            model.getDependencies().add(d);
            d = new Dependency();
            d.setGroupId("org.apache.camel.springboot");
            d.setArtifactId("camel-cli-connector-starter");
            model.getDependencies().add(d);

            Profile mp = new Profile();
            model.addProfile(mp);
            mp.setId("camel-debug");
            Activation a = new Activation();
            a.setActiveByDefault(true);
            mp.setActivation(a);

            Build b = new Build();
            mp.setBuild(b);

            Plugin pi = new Plugin();
            b.addPlugin(pi);
            pi.setGroupId("org.springframework.boot");
            pi.setArtifactId("spring-boot-maven-plugin");
            pi.setVersion("${spring-boot-version}");
            PluginExecution pe = new PluginExecution();
            pe.addGoal("repackage");
            pi.addExecution(pe);
            Xpp3Dom cfg = new Xpp3Dom("finalName");
            cfg.setValue("camel-jbang-debug");
            Xpp3Dom root = new Xpp3Dom("configuration");
            root.addChild(cfg);
            pi.setConfiguration(root);

            MavenXpp3Writer w = new MavenXpp3Writer();
            FileOutputStream fos = new FileOutputStream("camel-jbang-debug-pom.xml", false);
            w.write(fos, model);
            IOHelper.close(fos);

            printer().println("Preparing Camel Spring Boot for debugging ...");

             
            String mvnw = "/mvnw";
            if (FileUtil.isWindows()) {
                mvnw = "/mvnw.cmd";
            }
            if (!new File(mvnw).exists()) {
                mvnw = "mvn";
            }
             
            ProcessBuilder pb = new ProcessBuilder();
            pb.command(mvnw, "-Dmaven.test.skip", "--file", "camel-jbang-debug-pom.xml", "package", "spring-boot:repackage");
            Process p = pb.start();

            if (p.waitFor(30, TimeUnit.SECONDS)) {
                AtomicReference<Process> processRef = new AtomicReference<>();
                Runtime.getRuntime().addShutdownHook(new Thread(() -> {
                    try {
                         
                        Process process = processRef.get();
                        if (process != null) {
                            process.destroy();
                            for (int i = 0; i < 30; i++) {
                                if (!process.isAlive()) {
                                    break;
                                }
                                try {
                                    Thread.sleep(1000);
                                } catch (InterruptedException e) {
                                    Thread.currentThread().interrupt();
                                }
                            }
                        }
                        removeDir(Paths.get(RUN_PLATFORM_DIR));
                        removeDir(Paths.get(CAMEL_JBANG_WORK_DIR));
                        Files.deleteIfExists(Paths.get("camel-jbang-debug-pom.xml"));
                    } catch (Exception e) {
                         
                    }
                }));

                 
                pb = new ProcessBuilder();
                pb.command("java",
                        "-Dcamel.debug.enabled=true",
                        (breakpoint == null
                                ? "-Dcamel.debug.breakpoints=_all_routes_" : "-Dcamel.debug.breakpoints=" + breakpoint),
                        "-Dcamel.debug.loggingLevel=DEBUG",
                        "-Dcamel.debug.singleStepIncludeStartEnd=true",
                        loggingColor ? "-Dspring.output.ansi.enabled=ALWAYS" : "-Dspring.output.ansi.enabled=NEVER",
                        "-jar", "target/camel-jbang-debug.jar");

                p = pb.start();
                processRef.set(p);
                this.spawnOutput = p.getInputStream();
                this.spawnError = p.getErrorStream();
                this.spawnPid = p.pid();
                printer().println("Debugging Camel Spring Boot integration: " + name + " with PID: " + p.pid());
            } else {
                printer().printErr("Timed out preparing Camel Spring Boot for debugging");
                this.spawnError = p.getErrorStream();
                this.spawnPid = p.pid();
                p.destroy();
                return -1;
            }
        }

        return 0;
    }

    public static void parseXmlRouteCSimpleExpressions(
            InputStream xml, String baseDir, String fullyQualifiedFileName,
            List<CamelCSimpleExpressionDetails> csimpleExpressions) {

         
         
        Document dom = getDocument(xml);
        if (dom != null) {
            List<Node> nodes = CamelXmlHelper.findAllLanguageExpressions(dom, "csimple");
            for (Node node : nodes) {
                String simple = node.getTextContent();
                String lineNumber = (String) node.getUserData(XmlLineNumberParser.LINE_NUMBER);
                String lineNumberEnd = (String) node.getUserData(XmlLineNumberParser.LINE_NUMBER_END);

                 
                String fileName = getFileName(baseDir, fullyQualifiedFileName);

                CamelCSimpleExpressionDetails detail = new CamelCSimpleExpressionDetails();
                detail.setFileName(fileName);
                detail.setLineNumber(lineNumber);
                detail.setLineNumberEnd(lineNumberEnd);
                detail.setCsimple(simple);

                String column = (String) node.getUserData(XmlLineNumberParser.COLUMN_NUMBER);
                if (column != null) {
                    detail.setLinePosition(Integer.parseInt(column));
                }

                 
                boolean asPredicate = isSimplePredicate(node);
                detail.setPredicate(asPredicate);
                detail.setExpression(!asPredicate);

                csimpleExpressions.add(detail);
            }
        }
    }

    public Producer createProducer() throws Exception {
        switch (getSubsystem()) {
            case NovaConstants.NOVA_SUBSYSTEM_FLAVORS:
                return new FlavorsProducer(this, createClient());
            case NovaConstants.NOVA_SUBSYSTEM_SERVERS:
                return new ServerProducer(this, createClient());
            case NovaConstants.NOVA_SUBSYSTEM_KEYPAIRS:
                return new KeypairProducer(this, createClient());
            default:
                throw new IllegalArgumentException("Can't create producer with subsystem " + subsystem);
        }
    }

        public void onJoin(String channel, IRCUser user) {
            if (configuration.isOnJoin()) {
                Exchange exchange = createOnJoinExchange(channel, user);
                try {
                    getProcessor().process(exchange);
                } catch (Exception e) {
                    handleException(e);
                }
            }
        }

    private JAXBElement<Fault> createFaultFromException(final Throwable exception) {
        WebFault webFault = exception.getClass().getAnnotation(WebFault.class);
        if (webFault == null || webFault.targetNamespace() == null) {
            throw new RuntimeException(
                    "The exception " + exception.getClass().getName()
                                       + " needs to have an WebFault annotation with name and targetNamespace",
                    exception);
        }
        QName name = new QName(webFault.targetNamespace(), webFault.name());
        Object faultObject;
        try {
            Method method = exception.getClass().getMethod("getFaultInfo");
            faultObject = method.invoke(exception);
        } catch (Exception e) {
            throw new RuntimeCamelException("Exception while trying to get fault details", e);
        }

        Fault fault = new Fault();
        Faultcode code = new Faultcode();
        code.setValue(FAULT_CODE_SERVER);
        fault.setCode(code);

        Reasontext text = new Reasontext();
        text.setValue(exception.getMessage());
        text.setLang("en");
        fault.setReason(new Faultreason().withText(text));

        Detail detailEl = new ObjectFactory().createDetail();
        @SuppressWarnings("rawtypes")
        JAXBElement<?> faultDetailContent = new JAXBElement(name, faultObject.getClass(), faultObject);
        detailEl.getAny().add(faultDetailContent);
        fault.setDetail(detailEl);
        return new ObjectFactory().createFault(fault);
    }

    List<Row> collectRows() {
        List<Row> rows = new ArrayList<>();
        for (String name : catalog.findOtherNames()) {
            OtherModel model = catalog.otherModel(name);
            if (model != null) {
                Row row = new Row();
                row.name = model.getName();
                row.title = model.getTitle();
                row.level = model.getSupportLevel().name();
                row.since = model.getFirstVersionShort();
                row.description = model.getDescription();
                row.label = model.getLabel() != null ? model.getLabel() : "";
                row.deprecated = model.isDeprecated();
                row.nativeSupported = model.isNativeSupported();
                row.gav = getGAV(model);
                rows.add(row);
            }
        }
        return rows;
    }

    protected int sortRow(Row o1, Row o2) {
         
        int answer = super.sortRow(o1, o2);
        if (answer == 0) {
            int negate = 1;
            if (sort.startsWith("-")) {
                negate = -1;
            }
             
            long m1 = o1.mean != null ? Long.parseLong(o1.mean) : 0;
            long m2 = o2.mean != null ? Long.parseLong(o2.mean) : 0;
            if (m1 < m2) {
                answer = negate;
            } else if (m1 > m2) {
                answer = -1 * negate;
            }
        }
        return answer;
    }

    protected void doStart() throws Exception {
        super.doStart();

        if (getConfiguration().hasQueryBuilder()) {
            handler = new ContinuousQueryHandler();
        } else {
            handler = new ConsumerHandler();
        }

        ServiceHelper.startService(handler);
    }

    public static Region valueOf(String regionId) {
        if (StringUtils.isEmpty(regionId)) {
            throw new IllegalArgumentException("Unexpected empty parameter: regionId.");
        } else {
            Region result = STATIC_FIELDS.get(regionId);
            if (Objects.nonNull(result)) {
                return result;
            } else {
                throw new IllegalArgumentException("Unexpected regionId: " + regionId);
            }
        }
    }